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