ASTReader.cpp revision f33740efdb2d836a96ba97ca3004d46404401439 
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() << "*** AST File Remapping:\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
4380/// Return the amount of memory used by memory buffers, breaking down
4381/// by heap-backed versus mmap'ed memory.
4382void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4383  for (ModuleConstIterator I = ModuleMgr.begin(),
4384      E = ModuleMgr.end(); I != E; ++I) {
4385    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
4386      size_t bytes = buf->getBufferSize();
4387      switch (buf->getBufferKind()) {
4388        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4389          sizes.malloc_bytes += bytes;
4390          break;
4391        case llvm::MemoryBuffer::MemoryBuffer_MMap:
4392          sizes.mmap_bytes += bytes;
4393          break;
4394      }
4395    }
4396  }
4397}
4398
4399void ASTReader::InitializeSema(Sema &S) {
4400  SemaObj = &S;
4401  S.ExternalSource = this;
4402
4403  // Makes sure any declarations that were deserialized "too early"
4404  // still get added to the identifier's declaration chains.
4405  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4406    if (SemaObj->TUScope)
4407      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4408
4409    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4410  }
4411  PreloadedDecls.clear();
4412
4413  // Load the offsets of the declarations that Sema references.
4414  // They will be lazily deserialized when needed.
4415  if (!SemaDeclRefs.empty()) {
4416    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4417    if (!SemaObj->StdNamespace)
4418      SemaObj->StdNamespace = SemaDeclRefs[0];
4419    if (!SemaObj->StdBadAlloc)
4420      SemaObj->StdBadAlloc = SemaDeclRefs[1];
4421  }
4422
4423  if (!FPPragmaOptions.empty()) {
4424    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4425    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4426  }
4427
4428  if (!OpenCLExtensions.empty()) {
4429    unsigned I = 0;
4430#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4431#include "clang/Basic/OpenCLExtensions.def"
4432
4433    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4434  }
4435}
4436
4437IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4438  // Try to find this name within our on-disk hash tables. We start with the
4439  // most recent one, since that one contains the most up-to-date info.
4440  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4441    ASTIdentifierLookupTable *IdTable
4442        = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable;
4443    if (!IdTable)
4444      continue;
4445    std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
4446    ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
4447    if (Pos == IdTable->end())
4448      continue;
4449
4450    // Dereferencing the iterator has the effect of building the
4451    // IdentifierInfo node and populating it with the various
4452    // declarations it needs.
4453    return *Pos;
4454  }
4455  return 0;
4456}
4457
4458namespace clang {
4459  /// \brief An identifier-lookup iterator that enumerates all of the
4460  /// identifiers stored within a set of AST files.
4461  class ASTIdentifierIterator : public IdentifierIterator {
4462    /// \brief The AST reader whose identifiers are being enumerated.
4463    const ASTReader &Reader;
4464
4465    /// \brief The current index into the chain of AST files stored in
4466    /// the AST reader.
4467    unsigned Index;
4468
4469    /// \brief The current position within the identifier lookup table
4470    /// of the current AST file.
4471    ASTIdentifierLookupTable::key_iterator Current;
4472
4473    /// \brief The end position within the identifier lookup table of
4474    /// the current AST file.
4475    ASTIdentifierLookupTable::key_iterator End;
4476
4477  public:
4478    explicit ASTIdentifierIterator(const ASTReader &Reader);
4479
4480    virtual StringRef Next();
4481  };
4482}
4483
4484ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4485  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
4486  ASTIdentifierLookupTable *IdTable
4487    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
4488  Current = IdTable->key_begin();
4489  End = IdTable->key_end();
4490}
4491
4492StringRef ASTIdentifierIterator::Next() {
4493  while (Current == End) {
4494    // If we have exhausted all of our AST files, we're done.
4495    if (Index == 0)
4496      return StringRef();
4497
4498    --Index;
4499    ASTIdentifierLookupTable *IdTable
4500      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4501        IdentifierLookupTable;
4502    Current = IdTable->key_begin();
4503    End = IdTable->key_end();
4504  }
4505
4506  // We have any identifiers remaining in the current AST file; return
4507  // the next one.
4508  std::pair<const char*, unsigned> Key = *Current;
4509  ++Current;
4510  return StringRef(Key.first, Key.second);
4511}
4512
4513IdentifierIterator *ASTReader::getIdentifiers() const {
4514  return new ASTIdentifierIterator(*this);
4515}
4516
4517std::pair<ObjCMethodList, ObjCMethodList>
4518ASTReader::ReadMethodPool(Selector Sel) {
4519  // Find this selector in a hash table. We want to find the most recent entry.
4520  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4521    Module &F = *(*I);
4522    if (!F.SelectorLookupTable)
4523      continue;
4524
4525    ASTSelectorLookupTable *PoolTable
4526      = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4527    ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
4528    if (Pos != PoolTable->end()) {
4529      ++NumSelectorsRead;
4530      // FIXME: Not quite happy with the statistics here. We probably should
4531      // disable this tracking when called via LoadSelector.
4532      // Also, should entries without methods count as misses?
4533      ++NumMethodPoolEntriesRead;
4534      ASTSelectorLookupTrait::data_type Data = *Pos;
4535      if (DeserializationListener)
4536        DeserializationListener->SelectorRead(Data.ID, Sel);
4537      return std::make_pair(Data.Instance, Data.Factory);
4538    }
4539  }
4540
4541  ++NumMethodPoolMisses;
4542  return std::pair<ObjCMethodList, ObjCMethodList>();
4543}
4544
4545void ASTReader::ReadKnownNamespaces(
4546                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4547  Namespaces.clear();
4548
4549  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4550    if (NamespaceDecl *Namespace
4551                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4552      Namespaces.push_back(Namespace);
4553  }
4554}
4555
4556void ASTReader::ReadTentativeDefinitions(
4557                  SmallVectorImpl<VarDecl *> &TentativeDefs) {
4558  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4559    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
4560    if (Var)
4561      TentativeDefs.push_back(Var);
4562  }
4563  TentativeDefinitions.clear();
4564}
4565
4566void ASTReader::ReadUnusedFileScopedDecls(
4567                               SmallVectorImpl<const DeclaratorDecl *> &Decls) {
4568  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4569    DeclaratorDecl *D
4570      = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4571    if (D)
4572      Decls.push_back(D);
4573  }
4574  UnusedFileScopedDecls.clear();
4575}
4576
4577void ASTReader::ReadDelegatingConstructors(
4578                                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
4579  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4580    CXXConstructorDecl *D
4581      = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4582    if (D)
4583      Decls.push_back(D);
4584  }
4585  DelegatingCtorDecls.clear();
4586}
4587
4588void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
4589  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
4590    TypedefNameDecl *D
4591      = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
4592    if (D)
4593      Decls.push_back(D);
4594  }
4595  ExtVectorDecls.clear();
4596}
4597
4598void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
4599  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
4600    CXXRecordDecl *D
4601      = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
4602    if (D)
4603      Decls.push_back(D);
4604  }
4605  DynamicClasses.clear();
4606}
4607
4608void
4609ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
4610  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4611    NamedDecl *D
4612      = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4613    if (D)
4614      Decls.push_back(D);
4615  }
4616  LocallyScopedExternalDecls.clear();
4617}
4618
4619void ASTReader::ReadReferencedSelectors(
4620       SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
4621  if (ReferencedSelectorsData.empty())
4622    return;
4623
4624  // If there are @selector references added them to its pool. This is for
4625  // implementation of -Wselector.
4626  unsigned int DataSize = ReferencedSelectorsData.size()-1;
4627  unsigned I = 0;
4628  while (I < DataSize) {
4629    Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
4630    SourceLocation SelLoc
4631      = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
4632    Sels.push_back(std::make_pair(Sel, SelLoc));
4633  }
4634  ReferencedSelectorsData.clear();
4635}
4636
4637void ASTReader::ReadWeakUndeclaredIdentifiers(
4638       SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
4639  if (WeakUndeclaredIdentifiers.empty())
4640    return;
4641
4642  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
4643    IdentifierInfo *WeakId
4644      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4645    IdentifierInfo *AliasId
4646      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4647    SourceLocation Loc
4648      = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
4649    bool Used = WeakUndeclaredIdentifiers[I++];
4650    WeakInfo WI(AliasId, Loc);
4651    WI.setUsed(Used);
4652    WeakIDs.push_back(std::make_pair(WeakId, WI));
4653  }
4654  WeakUndeclaredIdentifiers.clear();
4655}
4656
4657void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
4658  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
4659    ExternalVTableUse VT;
4660    VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4661    VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
4662    VT.DefinitionRequired = VTableUses[Idx++];
4663    VTables.push_back(VT);
4664  }
4665
4666  VTableUses.clear();
4667}
4668
4669void ASTReader::ReadPendingInstantiations(
4670       SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
4671  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
4672    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
4673    SourceLocation Loc
4674      = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
4675    Pending.push_back(std::make_pair(D, Loc));
4676  }
4677  PendingInstantiations.clear();
4678}
4679
4680void ASTReader::LoadSelector(Selector Sel) {
4681  // It would be complicated to avoid reading the methods anyway. So don't.
4682  ReadMethodPool(Sel);
4683}
4684
4685void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
4686  assert(ID && "Non-zero identifier ID required");
4687  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4688  IdentifiersLoaded[ID - 1] = II;
4689  if (DeserializationListener)
4690    DeserializationListener->IdentifierRead(ID, II);
4691}
4692
4693/// \brief Set the globally-visible declarations associated with the given
4694/// identifier.
4695///
4696/// If the AST reader is currently in a state where the given declaration IDs
4697/// cannot safely be resolved, they are queued until it is safe to resolve
4698/// them.
4699///
4700/// \param II an IdentifierInfo that refers to one or more globally-visible
4701/// declarations.
4702///
4703/// \param DeclIDs the set of declaration IDs with the name @p II that are
4704/// visible at global scope.
4705///
4706/// \param Nonrecursive should be true to indicate that the caller knows that
4707/// this call is non-recursive, and therefore the globally-visible declarations
4708/// will not be placed onto the pending queue.
4709void
4710ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4711                              const SmallVectorImpl<uint32_t> &DeclIDs,
4712                                   bool Nonrecursive) {
4713  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4714    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4715    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4716    PII.II = II;
4717    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4718    return;
4719  }
4720
4721  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4722    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4723    if (SemaObj) {
4724      if (SemaObj->TUScope) {
4725        // Introduce this declaration into the translation-unit scope
4726        // and add it to the declaration chain for this identifier, so
4727        // that (unqualified) name lookup will find it.
4728        SemaObj->TUScope->AddDecl(D);
4729      }
4730      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4731    } else {
4732      // Queue this declaration so that it will be added to the
4733      // translation unit scope and identifier's declaration chain
4734      // once a Sema object is known.
4735      PreloadedDecls.push_back(D);
4736    }
4737  }
4738}
4739
4740IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
4741  if (ID == 0)
4742    return 0;
4743
4744  if (IdentifiersLoaded.empty()) {
4745    Error("no identifier table in AST file");
4746    return 0;
4747  }
4748
4749  assert(PP && "Forgot to set Preprocessor ?");
4750  ID -= 1;
4751  if (!IdentifiersLoaded[ID]) {
4752    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4753    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
4754    Module *M = I->second;
4755    unsigned Index = ID - M->BaseIdentifierID;
4756    const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
4757
4758    // All of the strings in the AST file are preceded by a 16-bit length.
4759    // Extract that 16-bit length to avoid having to execute strlen().
4760    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4761    //  unsigned integers.  This is important to avoid integer overflow when
4762    //  we cast them to 'unsigned'.
4763    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4764    unsigned StrLen = (((unsigned) StrLenPtr[0])
4765                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4766    IdentifiersLoaded[ID]
4767      = &PP->getIdentifierTable().get(StringRef(Str, StrLen));
4768    if (DeserializationListener)
4769      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4770  }
4771
4772  return IdentifiersLoaded[ID];
4773}
4774
4775IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
4776  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
4777}
4778
4779IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
4780  // FIXME: Perform local-to-global remapping
4781  return LocalID;
4782}
4783
4784bool ASTReader::ReadSLocEntry(int ID) {
4785  return ReadSLocEntryRecord(ID) != Success;
4786}
4787
4788Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
4789  return DecodeSelector(getGlobalSelectorID(M, LocalID));
4790}
4791
4792Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
4793  if (ID == 0)
4794    return Selector();
4795
4796  if (ID > SelectorsLoaded.size()) {
4797    Error("selector ID out of range in AST file");
4798    return Selector();
4799  }
4800
4801  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4802    // Load this selector from the selector table.
4803    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4804    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
4805    Module &M = *I->second;
4806    ASTSelectorLookupTrait Trait(*this, M);
4807    unsigned Idx = ID - 1 - M.BaseSelectorID;
4808    SelectorsLoaded[ID - 1] =
4809      Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
4810    if (DeserializationListener)
4811      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4812  }
4813
4814  return SelectorsLoaded[ID - 1];
4815}
4816
4817Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
4818  return DecodeSelector(ID);
4819}
4820
4821uint32_t ASTReader::GetNumExternalSelectors() {
4822  // ID 0 (the null selector) is considered an external selector.
4823  return getTotalNumSelectors() + 1;
4824}
4825
4826serialization::SelectorID
4827ASTReader::getGlobalSelectorID(Module &F, unsigned LocalID) const {
4828  // FIXME: Perform local -> global remapping
4829  return LocalID;
4830}
4831
4832DeclarationName
4833ASTReader::ReadDeclarationName(Module &F,
4834                               const RecordData &Record, unsigned &Idx) {
4835  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4836  switch (Kind) {
4837  case DeclarationName::Identifier:
4838    return DeclarationName(GetIdentifierInfo(F, Record, Idx));
4839
4840  case DeclarationName::ObjCZeroArgSelector:
4841  case DeclarationName::ObjCOneArgSelector:
4842  case DeclarationName::ObjCMultiArgSelector:
4843    return DeclarationName(ReadSelector(F, Record, Idx));
4844
4845  case DeclarationName::CXXConstructorName:
4846    return Context->DeclarationNames.getCXXConstructorName(
4847                          Context->getCanonicalType(readType(F, Record, Idx)));
4848
4849  case DeclarationName::CXXDestructorName:
4850    return Context->DeclarationNames.getCXXDestructorName(
4851                          Context->getCanonicalType(readType(F, Record, Idx)));
4852
4853  case DeclarationName::CXXConversionFunctionName:
4854    return Context->DeclarationNames.getCXXConversionFunctionName(
4855                          Context->getCanonicalType(readType(F, Record, Idx)));
4856
4857  case DeclarationName::CXXOperatorName:
4858    return Context->DeclarationNames.getCXXOperatorName(
4859                                       (OverloadedOperatorKind)Record[Idx++]);
4860
4861  case DeclarationName::CXXLiteralOperatorName:
4862    return Context->DeclarationNames.getCXXLiteralOperatorName(
4863                                       GetIdentifierInfo(F, Record, Idx));
4864
4865  case DeclarationName::CXXUsingDirective:
4866    return DeclarationName::getUsingDirectiveName();
4867  }
4868
4869  // Required to silence GCC warning
4870  return DeclarationName();
4871}
4872
4873void ASTReader::ReadDeclarationNameLoc(Module &F,
4874                                       DeclarationNameLoc &DNLoc,
4875                                       DeclarationName Name,
4876                                      const RecordData &Record, unsigned &Idx) {
4877  switch (Name.getNameKind()) {
4878  case DeclarationName::CXXConstructorName:
4879  case DeclarationName::CXXDestructorName:
4880  case DeclarationName::CXXConversionFunctionName:
4881    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4882    break;
4883
4884  case DeclarationName::CXXOperatorName:
4885    DNLoc.CXXOperatorName.BeginOpNameLoc
4886        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4887    DNLoc.CXXOperatorName.EndOpNameLoc
4888        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4889    break;
4890
4891  case DeclarationName::CXXLiteralOperatorName:
4892    DNLoc.CXXLiteralOperatorName.OpNameLoc
4893        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4894    break;
4895
4896  case DeclarationName::Identifier:
4897  case DeclarationName::ObjCZeroArgSelector:
4898  case DeclarationName::ObjCOneArgSelector:
4899  case DeclarationName::ObjCMultiArgSelector:
4900  case DeclarationName::CXXUsingDirective:
4901    break;
4902  }
4903}
4904
4905void ASTReader::ReadDeclarationNameInfo(Module &F,
4906                                        DeclarationNameInfo &NameInfo,
4907                                      const RecordData &Record, unsigned &Idx) {
4908  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
4909  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4910  DeclarationNameLoc DNLoc;
4911  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4912  NameInfo.setInfo(DNLoc);
4913}
4914
4915void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
4916                                  const RecordData &Record, unsigned &Idx) {
4917  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
4918  unsigned NumTPLists = Record[Idx++];
4919  Info.NumTemplParamLists = NumTPLists;
4920  if (NumTPLists) {
4921    Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
4922    for (unsigned i=0; i != NumTPLists; ++i)
4923      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4924  }
4925}
4926
4927TemplateName
4928ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
4929                            unsigned &Idx) {
4930  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
4931  switch (Kind) {
4932  case TemplateName::Template:
4933      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
4934
4935  case TemplateName::OverloadedTemplate: {
4936    unsigned size = Record[Idx++];
4937    UnresolvedSet<8> Decls;
4938    while (size--)
4939      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
4940
4941    return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
4942  }
4943
4944  case TemplateName::QualifiedTemplate: {
4945    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4946    bool hasTemplKeyword = Record[Idx++];
4947    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
4948    return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4949  }
4950
4951  case TemplateName::DependentTemplate: {
4952    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4953    if (Record[Idx++])  // isIdentifier
4954      return Context->getDependentTemplateName(NNS,
4955                                               GetIdentifierInfo(F, Record,
4956                                                                 Idx));
4957    return Context->getDependentTemplateName(NNS,
4958                                         (OverloadedOperatorKind)Record[Idx++]);
4959  }
4960
4961  case TemplateName::SubstTemplateTemplateParm: {
4962    TemplateTemplateParmDecl *param
4963      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4964    if (!param) return TemplateName();
4965    TemplateName replacement = ReadTemplateName(F, Record, Idx);
4966    return Context->getSubstTemplateTemplateParm(param, replacement);
4967  }
4968
4969  case TemplateName::SubstTemplateTemplateParmPack: {
4970    TemplateTemplateParmDecl *Param
4971      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4972    if (!Param)
4973      return TemplateName();
4974
4975    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4976    if (ArgPack.getKind() != TemplateArgument::Pack)
4977      return TemplateName();
4978
4979    return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
4980  }
4981  }
4982
4983  assert(0 && "Unhandled template name kind!");
4984  return TemplateName();
4985}
4986
4987TemplateArgument
4988ASTReader::ReadTemplateArgument(Module &F,
4989                                const RecordData &Record, unsigned &Idx) {
4990  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4991  switch (Kind) {
4992  case TemplateArgument::Null:
4993    return TemplateArgument();
4994  case TemplateArgument::Type:
4995    return TemplateArgument(readType(F, Record, Idx));
4996  case TemplateArgument::Declaration:
4997    return TemplateArgument(ReadDecl(F, Record, Idx));
4998  case TemplateArgument::Integral: {
4999    llvm::APSInt Value = ReadAPSInt(Record, Idx);
5000    QualType T = readType(F, Record, Idx);
5001    return TemplateArgument(Value, T);
5002  }
5003  case TemplateArgument::Template:
5004    return TemplateArgument(ReadTemplateName(F, Record, Idx));
5005  case TemplateArgument::TemplateExpansion: {
5006    TemplateName Name = ReadTemplateName(F, Record, Idx);
5007    llvm::Optional<unsigned> NumTemplateExpansions;
5008    if (unsigned NumExpansions = Record[Idx++])
5009      NumTemplateExpansions = NumExpansions - 1;
5010    return TemplateArgument(Name, NumTemplateExpansions);
5011  }
5012  case TemplateArgument::Expression:
5013    return TemplateArgument(ReadExpr(F));
5014  case TemplateArgument::Pack: {
5015    unsigned NumArgs = Record[Idx++];
5016    TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
5017    for (unsigned I = 0; I != NumArgs; ++I)
5018      Args[I] = ReadTemplateArgument(F, Record, Idx);
5019    return TemplateArgument(Args, NumArgs);
5020  }
5021  }
5022
5023  assert(0 && "Unhandled template argument kind!");
5024  return TemplateArgument();
5025}
5026
5027TemplateParameterList *
5028ASTReader::ReadTemplateParameterList(Module &F,
5029                                     const RecordData &Record, unsigned &Idx) {
5030  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
5031  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
5032  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
5033
5034  unsigned NumParams = Record[Idx++];
5035  SmallVector<NamedDecl *, 16> Params;
5036  Params.reserve(NumParams);
5037  while (NumParams--)
5038    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
5039
5040  TemplateParameterList* TemplateParams =
5041    TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
5042                                  Params.data(), Params.size(), RAngleLoc);
5043  return TemplateParams;
5044}
5045
5046void
5047ASTReader::
5048ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
5049                         Module &F, const RecordData &Record,
5050                         unsigned &Idx) {
5051  unsigned NumTemplateArgs = Record[Idx++];
5052  TemplArgs.reserve(NumTemplateArgs);
5053  while (NumTemplateArgs--)
5054    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
5055}
5056
5057/// \brief Read a UnresolvedSet structure.
5058void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
5059                                  const RecordData &Record, unsigned &Idx) {
5060  unsigned NumDecls = Record[Idx++];
5061  while (NumDecls--) {
5062    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
5063    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5064    Set.addDecl(D, AS);
5065  }
5066}
5067
5068CXXBaseSpecifier
5069ASTReader::ReadCXXBaseSpecifier(Module &F,
5070                                const RecordData &Record, unsigned &Idx) {
5071  bool isVirtual = static_cast<bool>(Record[Idx++]);
5072  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5073  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
5074  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
5075  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5076  SourceRange Range = ReadSourceRange(F, Record, Idx);
5077  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
5078  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
5079                          EllipsisLoc);
5080  Result.setInheritConstructors(inheritConstructors);
5081  return Result;
5082}
5083
5084std::pair<CXXCtorInitializer **, unsigned>
5085ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
5086                                   unsigned &Idx) {
5087  CXXCtorInitializer **CtorInitializers = 0;
5088  unsigned NumInitializers = Record[Idx++];
5089  if (NumInitializers) {
5090    ASTContext &C = *getContext();
5091
5092    CtorInitializers
5093        = new (C) CXXCtorInitializer*[NumInitializers];
5094    for (unsigned i=0; i != NumInitializers; ++i) {
5095      TypeSourceInfo *BaseClassInfo = 0;
5096      bool IsBaseVirtual = false;
5097      FieldDecl *Member = 0;
5098      IndirectFieldDecl *IndirectMember = 0;
5099      CXXConstructorDecl *Target = 0;
5100
5101      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5102      switch (Type) {
5103       case CTOR_INITIALIZER_BASE:
5104        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
5105        IsBaseVirtual = Record[Idx++];
5106        break;
5107
5108       case CTOR_INITIALIZER_DELEGATING:
5109        Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
5110        break;
5111
5112       case CTOR_INITIALIZER_MEMBER:
5113        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
5114        break;
5115
5116       case CTOR_INITIALIZER_INDIRECT_MEMBER:
5117        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
5118        break;
5119      }
5120
5121      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
5122      Expr *Init = ReadExpr(F);
5123      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
5124      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
5125      bool IsWritten = Record[Idx++];
5126      unsigned SourceOrderOrNumArrayIndices;
5127      SmallVector<VarDecl *, 8> Indices;
5128      if (IsWritten) {
5129        SourceOrderOrNumArrayIndices = Record[Idx++];
5130      } else {
5131        SourceOrderOrNumArrayIndices = Record[Idx++];
5132        Indices.reserve(SourceOrderOrNumArrayIndices);
5133        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
5134          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
5135      }
5136
5137      CXXCtorInitializer *BOMInit;
5138      if (Type == CTOR_INITIALIZER_BASE) {
5139        BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
5140                                             LParenLoc, Init, RParenLoc,
5141                                             MemberOrEllipsisLoc);
5142      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5143        BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
5144                                             Target, Init, RParenLoc);
5145      } else if (IsWritten) {
5146        if (Member)
5147          BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
5148                                               LParenLoc, Init, RParenLoc);
5149        else
5150          BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
5151                                               MemberOrEllipsisLoc, LParenLoc,
5152                                               Init, RParenLoc);
5153      } else {
5154        BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
5155                                             LParenLoc, Init, RParenLoc,
5156                                             Indices.data(), Indices.size());
5157      }
5158
5159      if (IsWritten)
5160        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
5161      CtorInitializers[i] = BOMInit;
5162    }
5163  }
5164
5165  return std::make_pair(CtorInitializers, NumInitializers);
5166}
5167
5168NestedNameSpecifier *
5169ASTReader::ReadNestedNameSpecifier(Module &F,
5170                                   const RecordData &Record, unsigned &Idx) {
5171  unsigned N = Record[Idx++];
5172  NestedNameSpecifier *NNS = 0, *Prev = 0;
5173  for (unsigned I = 0; I != N; ++I) {
5174    NestedNameSpecifier::SpecifierKind Kind
5175      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5176    switch (Kind) {
5177    case NestedNameSpecifier::Identifier: {
5178      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5179      NNS = NestedNameSpecifier::Create(*Context, Prev, II);
5180      break;
5181    }
5182
5183    case NestedNameSpecifier::Namespace: {
5184      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5185      NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
5186      break;
5187    }
5188
5189    case NestedNameSpecifier::NamespaceAlias: {
5190      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5191      NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
5192      break;
5193    }
5194
5195    case NestedNameSpecifier::TypeSpec:
5196    case NestedNameSpecifier::TypeSpecWithTemplate: {
5197      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
5198      if (!T)
5199        return 0;
5200
5201      bool Template = Record[Idx++];
5202      NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
5203      break;
5204    }
5205
5206    case NestedNameSpecifier::Global: {
5207      NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
5208      // No associated value, and there can't be a prefix.
5209      break;
5210    }
5211    }
5212    Prev = NNS;
5213  }
5214  return NNS;
5215}
5216
5217NestedNameSpecifierLoc
5218ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
5219                                      unsigned &Idx) {
5220  unsigned N = Record[Idx++];
5221  NestedNameSpecifierLocBuilder Builder;
5222  for (unsigned I = 0; I != N; ++I) {
5223    NestedNameSpecifier::SpecifierKind Kind
5224      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5225    switch (Kind) {
5226    case NestedNameSpecifier::Identifier: {
5227      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5228      SourceRange Range = ReadSourceRange(F, Record, Idx);
5229      Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
5230      break;
5231    }
5232
5233    case NestedNameSpecifier::Namespace: {
5234      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5235      SourceRange Range = ReadSourceRange(F, Record, Idx);
5236      Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
5237      break;
5238    }
5239
5240    case NestedNameSpecifier::NamespaceAlias: {
5241      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5242      SourceRange Range = ReadSourceRange(F, Record, Idx);
5243      Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
5244      break;
5245    }
5246
5247    case NestedNameSpecifier::TypeSpec:
5248    case NestedNameSpecifier::TypeSpecWithTemplate: {
5249      bool Template = Record[Idx++];
5250      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5251      if (!T)
5252        return NestedNameSpecifierLoc();
5253      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5254
5255      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5256      Builder.Extend(*Context,
5257                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5258                     T->getTypeLoc(), ColonColonLoc);
5259      break;
5260    }
5261
5262    case NestedNameSpecifier::Global: {
5263      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5264      Builder.MakeGlobal(*Context, ColonColonLoc);
5265      break;
5266    }
5267    }
5268  }
5269
5270  return Builder.getWithLocInContext(*Context);
5271}
5272
5273SourceRange
5274ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
5275                           unsigned &Idx) {
5276  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5277  SourceLocation end = ReadSourceLocation(F, Record, Idx);
5278  return SourceRange(beg, end);
5279}
5280
5281/// \brief Read an integral value
5282llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5283  unsigned BitWidth = Record[Idx++];
5284  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5285  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5286  Idx += NumWords;
5287  return Result;
5288}
5289
5290/// \brief Read a signed integral value
5291llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5292  bool isUnsigned = Record[Idx++];
5293  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5294}
5295
5296/// \brief Read a floating-point value
5297llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5298  return llvm::APFloat(ReadAPInt(Record, Idx));
5299}
5300
5301// \brief Read a string
5302std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5303  unsigned Len = Record[Idx++];
5304  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5305  Idx += Len;
5306  return Result;
5307}
5308
5309VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5310                                         unsigned &Idx) {
5311  unsigned Major = Record[Idx++];
5312  unsigned Minor = Record[Idx++];
5313  unsigned Subminor = Record[Idx++];
5314  if (Minor == 0)
5315    return VersionTuple(Major);
5316  if (Subminor == 0)
5317    return VersionTuple(Major, Minor - 1);
5318  return VersionTuple(Major, Minor - 1, Subminor - 1);
5319}
5320
5321CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
5322                                          const RecordData &Record,
5323                                          unsigned &Idx) {
5324  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
5325  return CXXTemporary::Create(*Context, Decl);
5326}
5327
5328DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5329  return Diag(SourceLocation(), DiagID);
5330}
5331
5332DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5333  return Diags.Report(Loc, DiagID);
5334}
5335
5336/// \brief Retrieve the identifier table associated with the
5337/// preprocessor.
5338IdentifierTable &ASTReader::getIdentifierTable() {
5339  assert(PP && "Forgot to set Preprocessor ?");
5340  return PP->getIdentifierTable();
5341}
5342
5343/// \brief Record that the given ID maps to the given switch-case
5344/// statement.
5345void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5346  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5347  SwitchCaseStmts[ID] = SC;
5348}
5349
5350/// \brief Retrieve the switch-case statement with the given ID.
5351SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5352  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5353  return SwitchCaseStmts[ID];
5354}
5355
5356void ASTReader::ClearSwitchCaseIDs() {
5357  SwitchCaseStmts.clear();
5358}
5359
5360void ASTReader::FinishedDeserializing() {
5361  assert(NumCurrentElementsDeserializing &&
5362         "FinishedDeserializing not paired with StartedDeserializing");
5363  if (NumCurrentElementsDeserializing == 1) {
5364    // If any identifiers with corresponding top-level declarations have
5365    // been loaded, load those declarations now.
5366    while (!PendingIdentifierInfos.empty()) {
5367      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5368                              PendingIdentifierInfos.front().DeclIDs, true);
5369      PendingIdentifierInfos.pop_front();
5370    }
5371
5372    // Ready to load previous declarations of Decls that were delayed.
5373    while (!PendingPreviousDecls.empty()) {
5374      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5375                                PendingPreviousDecls.front().second);
5376      PendingPreviousDecls.pop_front();
5377    }
5378
5379    // We are not in recursive loading, so it's safe to pass the "interesting"
5380    // decls to the consumer.
5381    if (Consumer)
5382      PassInterestingDeclsToConsumer();
5383
5384    assert(PendingForwardRefs.size() == 0 &&
5385           "Some forward refs did not get linked to the definition!");
5386  }
5387  --NumCurrentElementsDeserializing;
5388}
5389
5390ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
5391                     StringRef isysroot, bool DisableValidation,
5392                     bool DisableStatCache)
5393  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5394    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5395    Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
5396    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5397    RelocatablePCH(false), isysroot(isysroot),
5398    DisableValidation(DisableValidation),
5399    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5400    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5401    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5402    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5403    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5404    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5405    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5406    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5407    NumCXXBaseSpecifiersLoaded(0)
5408{
5409  SourceMgr.setExternalSLocEntrySource(this);
5410}
5411
5412ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
5413                     Diagnostic &Diags, StringRef isysroot,
5414                     bool DisableValidation, bool DisableStatCache)
5415  : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
5416    Diags(Diags), SemaObj(0), PP(0), Context(0),
5417    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5418    RelocatablePCH(false), isysroot(isysroot),
5419    DisableValidation(DisableValidation), DisableStatCache(DisableStatCache),
5420    NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0),
5421    TotalNumSLocEntries(0), NumStatementsRead(0),
5422    TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
5423    NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
5424    TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
5425    TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
5426    TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0),
5427    NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0)
5428{
5429  SourceMgr.setExternalSLocEntrySource(this);
5430}
5431
5432ASTReader::~ASTReader() {
5433  // Delete all visible decl lookup tables
5434  for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5435                                       E = DeclContextOffsets.end();
5436       I != E; ++I) {
5437    for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5438         J != F; ++J) {
5439      if (J->NameLookupTableData)
5440        delete static_cast<ASTDeclContextNameLookupTable*>(
5441            J->NameLookupTableData);
5442    }
5443  }
5444  for (DeclContextVisibleUpdatesPending::iterator
5445           I = PendingVisibleUpdates.begin(),
5446           E = PendingVisibleUpdates.end();
5447       I != E; ++I) {
5448    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5449                                             F = I->second.end();
5450         J != F; ++J)
5451      delete static_cast<ASTDeclContextNameLookupTable*>(*J);
5452  }
5453}
5454
5455Module::Module(ModuleKind Kind)
5456  : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0),
5457    SLocEntryBaseOffset(0), SLocEntryOffsets(0),
5458    SLocFileOffsets(0), LocalNumIdentifiers(0),
5459    IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0),
5460    IdentifierLookupTable(0), BasePreprocessedEntityID(0),
5461    LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0),
5462    BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0),
5463    HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
5464    HeaderFileFrameworkStrings(0),
5465    LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0),
5466    SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
5467    DeclOffsets(0), BaseDeclID(0),
5468    LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5469    BaseCXXBaseSpecifiersID(0),
5470    LocalNumTypes(0), TypeOffsets(0), BaseTypeID(0), StatCache(0),
5471    NumPreallocatedPreprocessingEntities(0)
5472{}
5473
5474Module::~Module() {
5475  delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
5476  delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
5477  delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5478}
5479
5480Module *ModuleManager::lookup(StringRef Name) {
5481  const FileEntry *Entry = FileMgr.getFile(Name);
5482  return Modules[Entry];
5483}
5484
5485/// \brief Creates a new module and adds it to the list of known modules
5486Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) {
5487  Module *Prev = !size() ? 0 : &getLastModule();
5488  Module *Current = new Module(Type);
5489
5490  Current->FileName = FileName.str();
5491
5492  Chain.push_back(Current);
5493  const FileEntry *Entry = FileMgr.getFile(FileName);
5494  Modules[Entry] = Current;
5495
5496  if (Prev) {
5497    Current->ImportedBy.insert(Prev);
5498    Prev->Imports.insert(Current);
5499  }
5500
5501  return *Current;
5502}
5503
5504/// \brief Exports the list of loaded modules with their corresponding names
5505void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) {
5506  Target.reserve(size());
5507  for (ModuleConstIterator I = Chain.begin(), E = Chain.end();
5508       I != E; ++I) {
5509    Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset,
5510                                  (*I)->FileName));
5511  }
5512  std::sort(Target.begin(), Target.end());
5513}
5514
5515ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { }
5516
5517ModuleManager::~ModuleManager() {
5518  for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5519    delete Chain[e - i - 1];
5520}
5521