ASTReader.cpp revision 79d6726921897811232554ed94c5d77b5b7b3fc0 
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 CHAINED_METADATA: {
2037      if (!First) {
2038        Error("CHAINED_METADATA is not first record in block");
2039        return Failure;
2040      }
2041      if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2042        Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
2043                                           : diag::warn_pch_version_too_new);
2044        return IgnorePCH;
2045      }
2046
2047      // Load the chained file, which is always a PCH file.
2048      // FIXME: This could end up being a module.
2049      switch(ReadASTCore(StringRef(BlobStart, BlobLen), MK_PCH)) {
2050      case Failure: return Failure;
2051        // If we have to ignore the dependency, we'll have to ignore this too.
2052      case IgnorePCH: return IgnorePCH;
2053      case Success: break;
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)) {
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 &F = ModuleMgr.addModule(FileName, Type);
2834
2835  if (FileName != "-") {
2836    CurrentDir = llvm::sys::path::parent_path(FileName);
2837    if (CurrentDir.empty()) CurrentDir = ".";
2838  }
2839
2840  if (llvm::MemoryBuffer *Buffer = ModuleMgr.lookupBuffer(FileName)) {
2841    F.Buffer.reset(Buffer);
2842    assert(F.Buffer && "Passed null buffer");
2843  } else {
2844    // Open the AST file.
2845    //
2846    // FIXME: This shouldn't be here, we should just take a raw_ostream.
2847    std::string ErrStr;
2848    llvm::error_code ec;
2849    if (FileName == "-") {
2850      ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
2851      if (ec)
2852        ErrStr = ec.message();
2853    } else
2854      F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
2855    if (!F.Buffer) {
2856      Error(ErrStr.c_str());
2857      return IgnorePCH;
2858    }
2859  }
2860
2861  // Initialize the stream
2862  F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
2863                    (const unsigned char *)F.Buffer->getBufferEnd());
2864  llvm::BitstreamCursor &Stream = F.Stream;
2865  Stream.init(F.StreamFile);
2866  F.SizeInBits = F.Buffer->getBufferSize() * 8;
2867
2868  // Sniff for the signature.
2869  if (Stream.Read(8) != 'C' ||
2870      Stream.Read(8) != 'P' ||
2871      Stream.Read(8) != 'C' ||
2872      Stream.Read(8) != 'H') {
2873    Diag(diag::err_not_a_pch_file) << FileName;
2874    return Failure;
2875  }
2876
2877  while (!Stream.AtEndOfStream()) {
2878    unsigned Code = Stream.ReadCode();
2879
2880    if (Code != llvm::bitc::ENTER_SUBBLOCK) {
2881      Error("invalid record at top-level of AST file");
2882      return Failure;
2883    }
2884
2885    unsigned BlockID = Stream.ReadSubBlockID();
2886
2887    // We only know the AST subblock ID.
2888    switch (BlockID) {
2889    case llvm::bitc::BLOCKINFO_BLOCK_ID:
2890      if (Stream.ReadBlockInfoBlock()) {
2891        Error("malformed BlockInfoBlock in AST file");
2892        return Failure;
2893      }
2894      break;
2895    case AST_BLOCK_ID:
2896      switch (ReadASTBlock(F)) {
2897      case Success:
2898        break;
2899
2900      case Failure:
2901        return Failure;
2902
2903      case IgnorePCH:
2904        // FIXME: We could consider reading through to the end of this
2905        // AST block, skipping subblocks, to see if there are other
2906        // AST blocks elsewhere.
2907
2908        // FIXME: We can't clear loaded slocentries anymore.
2909        //SourceMgr.ClearPreallocatedSLocEntries();
2910
2911        // Remove the stat cache.
2912        if (F.StatCache)
2913          FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
2914
2915        return IgnorePCH;
2916      }
2917      break;
2918    default:
2919      if (Stream.SkipBlock()) {
2920        Error("malformed block record in AST file");
2921        return Failure;
2922      }
2923      break;
2924    }
2925  }
2926
2927  // Once read, set the Module bit base offset and update the size in
2928  // bits of all files we've seen.
2929  F.GlobalBitOffset = TotalModulesSizeInBits;
2930  TotalModulesSizeInBits += F.SizeInBits;
2931  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
2932  return Success;
2933}
2934
2935void ASTReader::setPreprocessor(Preprocessor &pp) {
2936  PP = &pp;
2937
2938  if (unsigned N = getTotalNumPreprocessedEntities()) {
2939    if (!PP->getPreprocessingRecord())
2940      PP->createPreprocessingRecord(true);
2941    PP->getPreprocessingRecord()->SetExternalSource(*this);
2942    PP->getPreprocessingRecord()->allocateLoadedEntities(N);
2943  }
2944
2945  PP->getHeaderSearchInfo().SetExternalLookup(this);
2946  PP->getHeaderSearchInfo().SetExternalSource(this);
2947}
2948
2949void ASTReader::InitializeContext(ASTContext &Ctx) {
2950  Context = &Ctx;
2951  assert(Context && "Passed null context!");
2952
2953  assert(PP && "Forgot to set Preprocessor ?");
2954  PP->getIdentifierTable().setExternalIdentifierLookup(this);
2955  PP->setExternalSource(this);
2956
2957  // If we have an update block for the TU waiting, we have to add it before
2958  // deserializing the decl.
2959  TranslationUnitDecl *TU = Ctx.getTranslationUnitDecl();
2960  DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
2961  if (DCU != DeclContextOffsets.end()) {
2962    // Insertion could invalidate map, so grab vector.
2963    DeclContextInfos T;
2964    T.swap(DCU->second);
2965    DeclContextOffsets.erase(DCU);
2966    DeclContextOffsets[TU].swap(T);
2967  }
2968
2969  // If there's a listener, notify them that we "read" the translation unit.
2970  if (DeserializationListener)
2971    DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, TU);
2972
2973  // Make sure we load the declaration update records for the translation unit,
2974  // if there are any.
2975  loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, TU);
2976
2977  // Note that the translation unit has external lexical and visible storage.
2978  TU->setHasExternalLexicalStorage(true);
2979  TU->setHasExternalVisibleStorage(true);
2980
2981  // FIXME: Find a better way to deal with collisions between these
2982  // built-in types. Right now, we just ignore the problem.
2983
2984  // Load the special types.
2985  if (Context->getBuiltinVaListType().isNull()) {
2986    Context->setBuiltinVaListType(
2987      GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2988  }
2989
2990  if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) {
2991    if (Context->ObjCSelTypedefType.isNull())
2992      Context->ObjCSelTypedefType = GetType(Sel);
2993  }
2994
2995  if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) {
2996    if (Context->ObjCProtoType.isNull())
2997      Context->ObjCProtoType = GetType(Proto);
2998  }
2999
3000  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
3001    if (!Context->CFConstantStringTypeDecl)
3002      Context->setCFConstantStringType(GetType(String));
3003  }
3004
3005  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3006    QualType FileType = GetType(File);
3007    if (FileType.isNull()) {
3008      Error("FILE type is NULL");
3009      return;
3010    }
3011
3012    if (!Context->FILEDecl) {
3013      if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3014        Context->setFILEDecl(Typedef->getDecl());
3015      else {
3016        const TagType *Tag = FileType->getAs<TagType>();
3017        if (!Tag) {
3018          Error("Invalid FILE type in AST file");
3019          return;
3020        }
3021        Context->setFILEDecl(Tag->getDecl());
3022      }
3023    }
3024  }
3025
3026  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
3027    QualType Jmp_bufType = GetType(Jmp_buf);
3028    if (Jmp_bufType.isNull()) {
3029      Error("jmp_buf type is NULL");
3030      return;
3031    }
3032
3033    if (!Context->jmp_bufDecl) {
3034      if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3035        Context->setjmp_bufDecl(Typedef->getDecl());
3036      else {
3037        const TagType *Tag = Jmp_bufType->getAs<TagType>();
3038        if (!Tag) {
3039          Error("Invalid jmp_buf type in AST file");
3040          return;
3041        }
3042        Context->setjmp_bufDecl(Tag->getDecl());
3043      }
3044    }
3045  }
3046
3047  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
3048    QualType Sigjmp_bufType = GetType(Sigjmp_buf);
3049    if (Sigjmp_bufType.isNull()) {
3050      Error("sigjmp_buf type is NULL");
3051      return;
3052    }
3053
3054    if (!Context->sigjmp_bufDecl) {
3055      if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
3056        Context->setsigjmp_bufDecl(Typedef->getDecl());
3057      else {
3058        const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
3059        assert(Tag && "Invalid sigjmp_buf type in AST file");
3060        Context->setsigjmp_bufDecl(Tag->getDecl());
3061      }
3062    }
3063  }
3064
3065  if (unsigned ObjCIdRedef
3066        = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
3067    if (Context->ObjCIdRedefinitionType.isNull())
3068      Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
3069  }
3070
3071  if (unsigned ObjCClassRedef
3072        = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
3073    if (Context->ObjCClassRedefinitionType.isNull())
3074      Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
3075  }
3076
3077  if (unsigned ObjCSelRedef
3078        = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
3079    if (Context->ObjCSelRedefinitionType.isNull())
3080      Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
3081  }
3082
3083  if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED])
3084    Context->setInt128Installed();
3085
3086  ReadPragmaDiagnosticMappings(Context->getDiagnostics());
3087
3088  // If there were any CUDA special declarations, deserialize them.
3089  if (!CUDASpecialDeclRefs.empty()) {
3090    assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
3091    Context->setcudaConfigureCallDecl(
3092                           cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
3093  }
3094}
3095
3096/// \brief Retrieve the name of the original source file name
3097/// directly from the AST file, without actually loading the AST
3098/// file.
3099std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
3100                                             FileManager &FileMgr,
3101                                             Diagnostic &Diags) {
3102  // Open the AST file.
3103  std::string ErrStr;
3104  llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
3105  Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
3106  if (!Buffer) {
3107    Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
3108    return std::string();
3109  }
3110
3111  // Initialize the stream
3112  llvm::BitstreamReader StreamFile;
3113  llvm::BitstreamCursor Stream;
3114  StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
3115                  (const unsigned char *)Buffer->getBufferEnd());
3116  Stream.init(StreamFile);
3117
3118  // Sniff for the signature.
3119  if (Stream.Read(8) != 'C' ||
3120      Stream.Read(8) != 'P' ||
3121      Stream.Read(8) != 'C' ||
3122      Stream.Read(8) != 'H') {
3123    Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
3124    return std::string();
3125  }
3126
3127  RecordData Record;
3128  while (!Stream.AtEndOfStream()) {
3129    unsigned Code = Stream.ReadCode();
3130
3131    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3132      unsigned BlockID = Stream.ReadSubBlockID();
3133
3134      // We only know the AST subblock ID.
3135      switch (BlockID) {
3136      case AST_BLOCK_ID:
3137        if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
3138          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3139          return std::string();
3140        }
3141        break;
3142
3143      default:
3144        if (Stream.SkipBlock()) {
3145          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3146          return std::string();
3147        }
3148        break;
3149      }
3150      continue;
3151    }
3152
3153    if (Code == llvm::bitc::END_BLOCK) {
3154      if (Stream.ReadBlockEnd()) {
3155        Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
3156        return std::string();
3157      }
3158      continue;
3159    }
3160
3161    if (Code == llvm::bitc::DEFINE_ABBREV) {
3162      Stream.ReadAbbrevRecord();
3163      continue;
3164    }
3165
3166    Record.clear();
3167    const char *BlobStart = 0;
3168    unsigned BlobLen = 0;
3169    if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
3170          == ORIGINAL_FILE_NAME)
3171      return std::string(BlobStart, BlobLen);
3172  }
3173
3174  return std::string();
3175}
3176
3177/// \brief Parse the record that corresponds to a LangOptions data
3178/// structure.
3179///
3180/// This routine parses the language options from the AST file and then gives
3181/// them to the AST listener if one is set.
3182///
3183/// \returns true if the listener deems the file unacceptable, false otherwise.
3184bool ASTReader::ParseLanguageOptions(
3185                             const SmallVectorImpl<uint64_t> &Record) {
3186  if (Listener) {
3187    LangOptions LangOpts;
3188
3189  #define PARSE_LANGOPT(Option)                  \
3190      LangOpts.Option = Record[Idx];             \
3191      ++Idx
3192
3193    unsigned Idx = 0;
3194    PARSE_LANGOPT(Trigraphs);
3195    PARSE_LANGOPT(BCPLComment);
3196    PARSE_LANGOPT(DollarIdents);
3197    PARSE_LANGOPT(AsmPreprocessor);
3198    PARSE_LANGOPT(GNUMode);
3199    PARSE_LANGOPT(GNUKeywords);
3200    PARSE_LANGOPT(ImplicitInt);
3201    PARSE_LANGOPT(Digraphs);
3202    PARSE_LANGOPT(HexFloats);
3203    PARSE_LANGOPT(C99);
3204    PARSE_LANGOPT(C1X);
3205    PARSE_LANGOPT(Microsoft);
3206    PARSE_LANGOPT(CPlusPlus);
3207    PARSE_LANGOPT(CPlusPlus0x);
3208    PARSE_LANGOPT(CXXOperatorNames);
3209    PARSE_LANGOPT(ObjC1);
3210    PARSE_LANGOPT(ObjC2);
3211    PARSE_LANGOPT(ObjCNonFragileABI);
3212    PARSE_LANGOPT(ObjCNonFragileABI2);
3213    PARSE_LANGOPT(AppleKext);
3214    PARSE_LANGOPT(ObjCDefaultSynthProperties);
3215    PARSE_LANGOPT(ObjCInferRelatedResultType);
3216    PARSE_LANGOPT(NoConstantCFStrings);
3217    PARSE_LANGOPT(PascalStrings);
3218    PARSE_LANGOPT(WritableStrings);
3219    PARSE_LANGOPT(LaxVectorConversions);
3220    PARSE_LANGOPT(AltiVec);
3221    PARSE_LANGOPT(Exceptions);
3222    PARSE_LANGOPT(ObjCExceptions);
3223    PARSE_LANGOPT(CXXExceptions);
3224    PARSE_LANGOPT(SjLjExceptions);
3225    PARSE_LANGOPT(MSBitfields);
3226    PARSE_LANGOPT(NeXTRuntime);
3227    PARSE_LANGOPT(Freestanding);
3228    PARSE_LANGOPT(NoBuiltin);
3229    PARSE_LANGOPT(ThreadsafeStatics);
3230    PARSE_LANGOPT(POSIXThreads);
3231    PARSE_LANGOPT(Blocks);
3232    PARSE_LANGOPT(EmitAllDecls);
3233    PARSE_LANGOPT(MathErrno);
3234    LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
3235                                       Record[Idx++]);
3236    PARSE_LANGOPT(HeinousExtensions);
3237    PARSE_LANGOPT(Optimize);
3238    PARSE_LANGOPT(OptimizeSize);
3239    PARSE_LANGOPT(Static);
3240    PARSE_LANGOPT(PICLevel);
3241    PARSE_LANGOPT(GNUInline);
3242    PARSE_LANGOPT(NoInline);
3243    PARSE_LANGOPT(Deprecated);
3244    PARSE_LANGOPT(AccessControl);
3245    PARSE_LANGOPT(CharIsSigned);
3246    PARSE_LANGOPT(ShortWChar);
3247    PARSE_LANGOPT(ShortEnums);
3248    LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
3249    LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
3250    LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
3251                                   Record[Idx++]);
3252    PARSE_LANGOPT(InstantiationDepth);
3253    PARSE_LANGOPT(OpenCL);
3254    PARSE_LANGOPT(CUDA);
3255    PARSE_LANGOPT(CatchUndefined);
3256    PARSE_LANGOPT(DefaultFPContract);
3257    PARSE_LANGOPT(ElideConstructors);
3258    PARSE_LANGOPT(SpellChecking);
3259    PARSE_LANGOPT(MRTD);
3260    PARSE_LANGOPT(ObjCAutoRefCount);
3261    PARSE_LANGOPT(ObjCInferRelatedReturnType);
3262  #undef PARSE_LANGOPT
3263
3264    return Listener->ReadLanguageOptions(LangOpts);
3265  }
3266
3267  return false;
3268}
3269
3270void ASTReader::ReadPreprocessedEntities() {
3271  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3272    Module &F = *(*I);
3273    if (!F.PreprocessorDetailCursor.getBitStreamReader())
3274      continue;
3275
3276    SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
3277    F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
3278    while (LoadPreprocessedEntity(F)) { }
3279  }
3280}
3281
3282PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
3283  RecordLocation Loc = getLocalBitOffset(Offset);
3284
3285  // Keep track of where we are in the stream, then jump back there
3286  // after reading this entity.
3287  SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
3288  Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
3289  return LoadPreprocessedEntity(*Loc.F);
3290}
3291
3292HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3293  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3294    Module &F = *(*I);
3295
3296    HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(),
3297                              F.HeaderFileFrameworkStrings,
3298                              FE->getName());
3299
3300    HeaderFileInfoLookupTable *Table
3301      = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
3302    if (!Table)
3303      continue;
3304
3305    // Look in the on-disk hash table for an entry for this file name.
3306    HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
3307                                                          &Trait);
3308    if (Pos == Table->end())
3309      continue;
3310
3311    HeaderFileInfo HFI = *Pos;
3312    if (Listener)
3313      Listener->ReadHeaderFileInfo(HFI, FE->getUID());
3314
3315    return HFI;
3316  }
3317
3318  return HeaderFileInfo();
3319}
3320
3321void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
3322  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3323    Module &F = *(*I);
3324    unsigned Idx = 0;
3325    while (Idx < F.PragmaDiagMappings.size()) {
3326      SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3327      while (1) {
3328        assert(Idx < F.PragmaDiagMappings.size() &&
3329               "Invalid data, didn't find '-1' marking end of diag/map pairs");
3330        if (Idx >= F.PragmaDiagMappings.size()) {
3331          break; // Something is messed up but at least avoid infinite loop in
3332                 // release build.
3333        }
3334        unsigned DiagID = F.PragmaDiagMappings[Idx++];
3335        if (DiagID == (unsigned)-1) {
3336          break; // no more diag/map pairs for this location.
3337        }
3338        diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3339        Diag.setDiagnosticMapping(DiagID, Map, Loc);
3340      }
3341    }
3342  }
3343}
3344
3345/// \brief Get the correct cursor and offset for loading a type.
3346ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3347  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
3348  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
3349  Module *M = I->second;
3350  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
3351}
3352
3353/// \brief Read and return the type with the given index..
3354///
3355/// The index is the type ID, shifted and minus the number of predefs. This
3356/// routine actually reads the record corresponding to the type at the given
3357/// location. It is a helper routine for GetType, which deals with reading type
3358/// IDs.
3359QualType ASTReader::readTypeRecord(unsigned Index) {
3360  RecordLocation Loc = TypeCursorForIndex(Index);
3361  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3362
3363  // Keep track of where we are in the stream, then jump back there
3364  // after reading this type.
3365  SavedStreamPosition SavedPosition(DeclsCursor);
3366
3367  ReadingKindTracker ReadingKind(Read_Type, *this);
3368
3369  // Note that we are loading a type record.
3370  Deserializing AType(this);
3371
3372  unsigned Idx = 0;
3373  DeclsCursor.JumpToBit(Loc.Offset);
3374  RecordData Record;
3375  unsigned Code = DeclsCursor.ReadCode();
3376  switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3377  case TYPE_EXT_QUAL: {
3378    if (Record.size() != 2) {
3379      Error("Incorrect encoding of extended qualifier type");
3380      return QualType();
3381    }
3382    QualType Base = readType(*Loc.F, Record, Idx);
3383    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
3384    return Context->getQualifiedType(Base, Quals);
3385  }
3386
3387  case TYPE_COMPLEX: {
3388    if (Record.size() != 1) {
3389      Error("Incorrect encoding of complex type");
3390      return QualType();
3391    }
3392    QualType ElemType = readType(*Loc.F, Record, Idx);
3393    return Context->getComplexType(ElemType);
3394  }
3395
3396  case TYPE_POINTER: {
3397    if (Record.size() != 1) {
3398      Error("Incorrect encoding of pointer type");
3399      return QualType();
3400    }
3401    QualType PointeeType = readType(*Loc.F, Record, Idx);
3402    return Context->getPointerType(PointeeType);
3403  }
3404
3405  case TYPE_BLOCK_POINTER: {
3406    if (Record.size() != 1) {
3407      Error("Incorrect encoding of block pointer type");
3408      return QualType();
3409    }
3410    QualType PointeeType = readType(*Loc.F, Record, Idx);
3411    return Context->getBlockPointerType(PointeeType);
3412  }
3413
3414  case TYPE_LVALUE_REFERENCE: {
3415    if (Record.size() != 2) {
3416      Error("Incorrect encoding of lvalue reference type");
3417      return QualType();
3418    }
3419    QualType PointeeType = readType(*Loc.F, Record, Idx);
3420    return Context->getLValueReferenceType(PointeeType, Record[1]);
3421  }
3422
3423  case TYPE_RVALUE_REFERENCE: {
3424    if (Record.size() != 1) {
3425      Error("Incorrect encoding of rvalue reference type");
3426      return QualType();
3427    }
3428    QualType PointeeType = readType(*Loc.F, Record, Idx);
3429    return Context->getRValueReferenceType(PointeeType);
3430  }
3431
3432  case TYPE_MEMBER_POINTER: {
3433    if (Record.size() != 2) {
3434      Error("Incorrect encoding of member pointer type");
3435      return QualType();
3436    }
3437    QualType PointeeType = readType(*Loc.F, Record, Idx);
3438    QualType ClassType = readType(*Loc.F, Record, Idx);
3439    if (PointeeType.isNull() || ClassType.isNull())
3440      return QualType();
3441
3442    return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
3443  }
3444
3445  case TYPE_CONSTANT_ARRAY: {
3446    QualType ElementType = readType(*Loc.F, Record, Idx);
3447    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3448    unsigned IndexTypeQuals = Record[2];
3449    unsigned Idx = 3;
3450    llvm::APInt Size = ReadAPInt(Record, Idx);
3451    return Context->getConstantArrayType(ElementType, Size,
3452                                         ASM, IndexTypeQuals);
3453  }
3454
3455  case TYPE_INCOMPLETE_ARRAY: {
3456    QualType ElementType = readType(*Loc.F, Record, Idx);
3457    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3458    unsigned IndexTypeQuals = Record[2];
3459    return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3460  }
3461
3462  case TYPE_VARIABLE_ARRAY: {
3463    QualType ElementType = readType(*Loc.F, Record, Idx);
3464    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3465    unsigned IndexTypeQuals = Record[2];
3466    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3467    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3468    return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3469                                         ASM, IndexTypeQuals,
3470                                         SourceRange(LBLoc, RBLoc));
3471  }
3472
3473  case TYPE_VECTOR: {
3474    if (Record.size() != 3) {
3475      Error("incorrect encoding of vector type in AST file");
3476      return QualType();
3477    }
3478
3479    QualType ElementType = readType(*Loc.F, Record, Idx);
3480    unsigned NumElements = Record[1];
3481    unsigned VecKind = Record[2];
3482    return Context->getVectorType(ElementType, NumElements,
3483                                  (VectorType::VectorKind)VecKind);
3484  }
3485
3486  case TYPE_EXT_VECTOR: {
3487    if (Record.size() != 3) {
3488      Error("incorrect encoding of extended vector type in AST file");
3489      return QualType();
3490    }
3491
3492    QualType ElementType = readType(*Loc.F, Record, Idx);
3493    unsigned NumElements = Record[1];
3494    return Context->getExtVectorType(ElementType, NumElements);
3495  }
3496
3497  case TYPE_FUNCTION_NO_PROTO: {
3498    if (Record.size() != 6) {
3499      Error("incorrect encoding of no-proto function type");
3500      return QualType();
3501    }
3502    QualType ResultType = readType(*Loc.F, Record, Idx);
3503    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3504                               (CallingConv)Record[4], Record[5]);
3505    return Context->getFunctionNoProtoType(ResultType, Info);
3506  }
3507
3508  case TYPE_FUNCTION_PROTO: {
3509    QualType ResultType = readType(*Loc.F, Record, Idx);
3510
3511    FunctionProtoType::ExtProtoInfo EPI;
3512    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3513                                        /*hasregparm*/ Record[2],
3514                                        /*regparm*/ Record[3],
3515                                        static_cast<CallingConv>(Record[4]),
3516                                        /*produces*/ Record[5]);
3517
3518    unsigned Idx = 6;
3519    unsigned NumParams = Record[Idx++];
3520    SmallVector<QualType, 16> ParamTypes;
3521    for (unsigned I = 0; I != NumParams; ++I)
3522      ParamTypes.push_back(readType(*Loc.F, Record, Idx));
3523
3524    EPI.Variadic = Record[Idx++];
3525    EPI.TypeQuals = Record[Idx++];
3526    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3527    ExceptionSpecificationType EST =
3528        static_cast<ExceptionSpecificationType>(Record[Idx++]);
3529    EPI.ExceptionSpecType = EST;
3530    if (EST == EST_Dynamic) {
3531      EPI.NumExceptions = Record[Idx++];
3532      SmallVector<QualType, 2> Exceptions;
3533      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3534        Exceptions.push_back(readType(*Loc.F, Record, Idx));
3535      EPI.Exceptions = Exceptions.data();
3536    } else if (EST == EST_ComputedNoexcept) {
3537      EPI.NoexceptExpr = ReadExpr(*Loc.F);
3538    }
3539    return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
3540                                    EPI);
3541  }
3542
3543  case TYPE_UNRESOLVED_USING: {
3544    unsigned Idx = 0;
3545    return Context->getTypeDeclType(
3546                  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3547  }
3548
3549  case TYPE_TYPEDEF: {
3550    if (Record.size() != 2) {
3551      Error("incorrect encoding of typedef type");
3552      return QualType();
3553    }
3554    unsigned Idx = 0;
3555    TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
3556    QualType Canonical = readType(*Loc.F, Record, Idx);
3557    if (!Canonical.isNull())
3558      Canonical = Context->getCanonicalType(Canonical);
3559    return Context->getTypedefType(Decl, Canonical);
3560  }
3561
3562  case TYPE_TYPEOF_EXPR:
3563    return Context->getTypeOfExprType(ReadExpr(*Loc.F));
3564
3565  case TYPE_TYPEOF: {
3566    if (Record.size() != 1) {
3567      Error("incorrect encoding of typeof(type) in AST file");
3568      return QualType();
3569    }
3570    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3571    return Context->getTypeOfType(UnderlyingType);
3572  }
3573
3574  case TYPE_DECLTYPE:
3575    return Context->getDecltypeType(ReadExpr(*Loc.F));
3576
3577  case TYPE_UNARY_TRANSFORM: {
3578    QualType BaseType = readType(*Loc.F, Record, Idx);
3579    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3580    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3581    return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
3582  }
3583
3584  case TYPE_AUTO:
3585    return Context->getAutoType(readType(*Loc.F, Record, Idx));
3586
3587  case TYPE_RECORD: {
3588    if (Record.size() != 2) {
3589      Error("incorrect encoding of record type");
3590      return QualType();
3591    }
3592    unsigned Idx = 0;
3593    bool IsDependent = Record[Idx++];
3594    QualType T
3595      = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
3596    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3597    return T;
3598  }
3599
3600  case TYPE_ENUM: {
3601    if (Record.size() != 2) {
3602      Error("incorrect encoding of enum type");
3603      return QualType();
3604    }
3605    unsigned Idx = 0;
3606    bool IsDependent = Record[Idx++];
3607    QualType T
3608      = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
3609    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3610    return T;
3611  }
3612
3613  case TYPE_ATTRIBUTED: {
3614    if (Record.size() != 3) {
3615      Error("incorrect encoding of attributed type");
3616      return QualType();
3617    }
3618    QualType modifiedType = readType(*Loc.F, Record, Idx);
3619    QualType equivalentType = readType(*Loc.F, Record, Idx);
3620    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3621    return Context->getAttributedType(kind, modifiedType, equivalentType);
3622  }
3623
3624  case TYPE_PAREN: {
3625    if (Record.size() != 1) {
3626      Error("incorrect encoding of paren type");
3627      return QualType();
3628    }
3629    QualType InnerType = readType(*Loc.F, Record, Idx);
3630    return Context->getParenType(InnerType);
3631  }
3632
3633  case TYPE_PACK_EXPANSION: {
3634    if (Record.size() != 2) {
3635      Error("incorrect encoding of pack expansion type");
3636      return QualType();
3637    }
3638    QualType Pattern = readType(*Loc.F, Record, Idx);
3639    if (Pattern.isNull())
3640      return QualType();
3641    llvm::Optional<unsigned> NumExpansions;
3642    if (Record[1])
3643      NumExpansions = Record[1] - 1;
3644    return Context->getPackExpansionType(Pattern, NumExpansions);
3645  }
3646
3647  case TYPE_ELABORATED: {
3648    unsigned Idx = 0;
3649    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3650    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3651    QualType NamedType = readType(*Loc.F, Record, Idx);
3652    return Context->getElaboratedType(Keyword, NNS, NamedType);
3653  }
3654
3655  case TYPE_OBJC_INTERFACE: {
3656    unsigned Idx = 0;
3657    ObjCInterfaceDecl *ItfD
3658      = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
3659    return Context->getObjCInterfaceType(ItfD);
3660  }
3661
3662  case TYPE_OBJC_OBJECT: {
3663    unsigned Idx = 0;
3664    QualType Base = readType(*Loc.F, Record, Idx);
3665    unsigned NumProtos = Record[Idx++];
3666    SmallVector<ObjCProtocolDecl*, 4> Protos;
3667    for (unsigned I = 0; I != NumProtos; ++I)
3668      Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
3669    return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
3670  }
3671
3672  case TYPE_OBJC_OBJECT_POINTER: {
3673    unsigned Idx = 0;
3674    QualType Pointee = readType(*Loc.F, Record, Idx);
3675    return Context->getObjCObjectPointerType(Pointee);
3676  }
3677
3678  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3679    unsigned Idx = 0;
3680    QualType Parm = readType(*Loc.F, Record, Idx);
3681    QualType Replacement = readType(*Loc.F, Record, Idx);
3682    return
3683      Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3684                                            Replacement);
3685  }
3686
3687  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3688    unsigned Idx = 0;
3689    QualType Parm = readType(*Loc.F, Record, Idx);
3690    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3691    return Context->getSubstTemplateTypeParmPackType(
3692                                               cast<TemplateTypeParmType>(Parm),
3693                                                     ArgPack);
3694  }
3695
3696  case TYPE_INJECTED_CLASS_NAME: {
3697    CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
3698    QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
3699    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3700    // for AST reading, too much interdependencies.
3701    return
3702      QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3703  }
3704
3705  case TYPE_TEMPLATE_TYPE_PARM: {
3706    unsigned Idx = 0;
3707    unsigned Depth = Record[Idx++];
3708    unsigned Index = Record[Idx++];
3709    bool Pack = Record[Idx++];
3710    TemplateTypeParmDecl *D
3711      = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
3712    return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
3713  }
3714
3715  case TYPE_DEPENDENT_NAME: {
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    QualType Canon = readType(*Loc.F, Record, Idx);
3721    if (!Canon.isNull())
3722      Canon = Context->getCanonicalType(Canon);
3723    return Context->getDependentNameType(Keyword, NNS, Name, Canon);
3724  }
3725
3726  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3727    unsigned Idx = 0;
3728    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3729    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3730    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3731    unsigned NumArgs = Record[Idx++];
3732    SmallVector<TemplateArgument, 8> Args;
3733    Args.reserve(NumArgs);
3734    while (NumArgs--)
3735      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3736    return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3737                                                      Args.size(), Args.data());
3738  }
3739
3740  case TYPE_DEPENDENT_SIZED_ARRAY: {
3741    unsigned Idx = 0;
3742
3743    // ArrayType
3744    QualType ElementType = readType(*Loc.F, Record, Idx);
3745    ArrayType::ArraySizeModifier ASM
3746      = (ArrayType::ArraySizeModifier)Record[Idx++];
3747    unsigned IndexTypeQuals = Record[Idx++];
3748
3749    // DependentSizedArrayType
3750    Expr *NumElts = ReadExpr(*Loc.F);
3751    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3752
3753    return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3754                                               IndexTypeQuals, Brackets);
3755  }
3756
3757  case TYPE_TEMPLATE_SPECIALIZATION: {
3758    unsigned Idx = 0;
3759    bool IsDependent = Record[Idx++];
3760    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3761    SmallVector<TemplateArgument, 8> Args;
3762    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3763    QualType Underlying = readType(*Loc.F, Record, Idx);
3764    QualType T;
3765    if (Underlying.isNull())
3766      T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3767                                                          Args.size());
3768    else
3769      T = Context->getTemplateSpecializationType(Name, Args.data(),
3770                                                 Args.size(), Underlying);
3771    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3772    return T;
3773  }
3774  }
3775  // Suppress a GCC warning
3776  return QualType();
3777}
3778
3779class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3780  ASTReader &Reader;
3781  Module &F;
3782  llvm::BitstreamCursor &DeclsCursor;
3783  const ASTReader::RecordData &Record;
3784  unsigned &Idx;
3785
3786  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3787                                    unsigned &I) {
3788    return Reader.ReadSourceLocation(F, R, I);
3789  }
3790
3791  template<typename T>
3792  T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
3793    return Reader.ReadDeclAs<T>(F, Record, Idx);
3794  }
3795
3796public:
3797  TypeLocReader(ASTReader &Reader, Module &F,
3798                const ASTReader::RecordData &Record, unsigned &Idx)
3799    : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3800  { }
3801
3802  // We want compile-time assurance that we've enumerated all of
3803  // these, so unfortunately we have to declare them first, then
3804  // define them out-of-line.
3805#define ABSTRACT_TYPELOC(CLASS, PARENT)
3806#define TYPELOC(CLASS, PARENT) \
3807  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3808#include "clang/AST/TypeLocNodes.def"
3809
3810  void VisitFunctionTypeLoc(FunctionTypeLoc);
3811  void VisitArrayTypeLoc(ArrayTypeLoc);
3812};
3813
3814void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3815  // nothing to do
3816}
3817void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3818  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3819  if (TL.needsExtraLocalData()) {
3820    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3821    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3822    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3823    TL.setModeAttr(Record[Idx++]);
3824  }
3825}
3826void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3827  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3828}
3829void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3830  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3831}
3832void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3833  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3834}
3835void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3836  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3837}
3838void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3839  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3840}
3841void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3842  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3843  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3844}
3845void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3846  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3847  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3848  if (Record[Idx++])
3849    TL.setSizeExpr(Reader.ReadExpr(F));
3850  else
3851    TL.setSizeExpr(0);
3852}
3853void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3854  VisitArrayTypeLoc(TL);
3855}
3856void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3857  VisitArrayTypeLoc(TL);
3858}
3859void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3860  VisitArrayTypeLoc(TL);
3861}
3862void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3863                                            DependentSizedArrayTypeLoc TL) {
3864  VisitArrayTypeLoc(TL);
3865}
3866void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3867                                        DependentSizedExtVectorTypeLoc TL) {
3868  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3869}
3870void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3871  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3872}
3873void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3874  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3875}
3876void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3877  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3878  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3879  TL.setTrailingReturn(Record[Idx++]);
3880  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3881    TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
3882  }
3883}
3884void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3885  VisitFunctionTypeLoc(TL);
3886}
3887void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3888  VisitFunctionTypeLoc(TL);
3889}
3890void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3891  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3892}
3893void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3894  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3895}
3896void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3897  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3898  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3899  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3900}
3901void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3902  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3903  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3904  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3905  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3906}
3907void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3908  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3909}
3910void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3911  TL.setKWLoc(ReadSourceLocation(Record, Idx));
3912  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3913  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3914  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3915}
3916void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3917  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3918}
3919void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3920  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3921}
3922void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3923  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3924}
3925void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3926  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3927  if (TL.hasAttrOperand()) {
3928    SourceRange range;
3929    range.setBegin(ReadSourceLocation(Record, Idx));
3930    range.setEnd(ReadSourceLocation(Record, Idx));
3931    TL.setAttrOperandParensRange(range);
3932  }
3933  if (TL.hasAttrExprOperand()) {
3934    if (Record[Idx++])
3935      TL.setAttrExprOperand(Reader.ReadExpr(F));
3936    else
3937      TL.setAttrExprOperand(0);
3938  } else if (TL.hasAttrEnumOperand())
3939    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3940}
3941void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3942  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3943}
3944void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3945                                            SubstTemplateTypeParmTypeLoc TL) {
3946  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3947}
3948void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3949                                          SubstTemplateTypeParmPackTypeLoc TL) {
3950  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3951}
3952void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3953                                           TemplateSpecializationTypeLoc TL) {
3954  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3955  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3956  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3957  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3958    TL.setArgLocInfo(i,
3959        Reader.GetTemplateArgumentLocInfo(F,
3960                                          TL.getTypePtr()->getArg(i).getKind(),
3961                                          Record, Idx));
3962}
3963void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3964  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3965  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3966}
3967void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3968  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3969  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3970}
3971void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3972  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3973}
3974void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3975  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3976  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3977  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3978}
3979void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3980       DependentTemplateSpecializationTypeLoc TL) {
3981  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3982  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3983  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3984  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3985  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3986  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3987    TL.setArgLocInfo(I,
3988        Reader.GetTemplateArgumentLocInfo(F,
3989                                          TL.getTypePtr()->getArg(I).getKind(),
3990                                          Record, Idx));
3991}
3992void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3993  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3994}
3995void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3996  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3997}
3998void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3999  TL.setHasBaseTypeAsWritten(Record[Idx++]);
4000  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4001  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
4002  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
4003    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
4004}
4005void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
4006  TL.setStarLoc(ReadSourceLocation(Record, Idx));
4007}
4008
4009TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
4010                                             const RecordData &Record,
4011                                             unsigned &Idx) {
4012  QualType InfoTy = readType(F, Record, Idx);
4013  if (InfoTy.isNull())
4014    return 0;
4015
4016  TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
4017  TypeLocReader TLR(*this, F, Record, Idx);
4018  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
4019    TLR.Visit(TL);
4020  return TInfo;
4021}
4022
4023QualType ASTReader::GetType(TypeID ID) {
4024  unsigned FastQuals = ID & Qualifiers::FastMask;
4025  unsigned Index = ID >> Qualifiers::FastWidth;
4026
4027  if (Index < NUM_PREDEF_TYPE_IDS) {
4028    QualType T;
4029    switch ((PredefinedTypeIDs)Index) {
4030    case PREDEF_TYPE_NULL_ID: return QualType();
4031    case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
4032    case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
4033
4034    case PREDEF_TYPE_CHAR_U_ID:
4035    case PREDEF_TYPE_CHAR_S_ID:
4036      // FIXME: Check that the signedness of CharTy is correct!
4037      T = Context->CharTy;
4038      break;
4039
4040    case PREDEF_TYPE_UCHAR_ID:      T = Context->UnsignedCharTy;     break;
4041    case PREDEF_TYPE_USHORT_ID:     T = Context->UnsignedShortTy;    break;
4042    case PREDEF_TYPE_UINT_ID:       T = Context->UnsignedIntTy;      break;
4043    case PREDEF_TYPE_ULONG_ID:      T = Context->UnsignedLongTy;     break;
4044    case PREDEF_TYPE_ULONGLONG_ID:  T = Context->UnsignedLongLongTy; break;
4045    case PREDEF_TYPE_UINT128_ID:    T = Context->UnsignedInt128Ty;   break;
4046    case PREDEF_TYPE_SCHAR_ID:      T = Context->SignedCharTy;       break;
4047    case PREDEF_TYPE_WCHAR_ID:      T = Context->WCharTy;            break;
4048    case PREDEF_TYPE_SHORT_ID:      T = Context->ShortTy;            break;
4049    case PREDEF_TYPE_INT_ID:        T = Context->IntTy;              break;
4050    case PREDEF_TYPE_LONG_ID:       T = Context->LongTy;             break;
4051    case PREDEF_TYPE_LONGLONG_ID:   T = Context->LongLongTy;         break;
4052    case PREDEF_TYPE_INT128_ID:     T = Context->Int128Ty;           break;
4053    case PREDEF_TYPE_FLOAT_ID:      T = Context->FloatTy;            break;
4054    case PREDEF_TYPE_DOUBLE_ID:     T = Context->DoubleTy;           break;
4055    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy;       break;
4056    case PREDEF_TYPE_OVERLOAD_ID:   T = Context->OverloadTy;         break;
4057    case PREDEF_TYPE_BOUND_MEMBER:  T = Context->BoundMemberTy;      break;
4058    case PREDEF_TYPE_DEPENDENT_ID:  T = Context->DependentTy;        break;
4059    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context->UnknownAnyTy;       break;
4060    case PREDEF_TYPE_NULLPTR_ID:    T = Context->NullPtrTy;          break;
4061    case PREDEF_TYPE_CHAR16_ID:     T = Context->Char16Ty;           break;
4062    case PREDEF_TYPE_CHAR32_ID:     T = Context->Char32Ty;           break;
4063    case PREDEF_TYPE_OBJC_ID:       T = Context->ObjCBuiltinIdTy;    break;
4064    case PREDEF_TYPE_OBJC_CLASS:    T = Context->ObjCBuiltinClassTy; break;
4065    case PREDEF_TYPE_OBJC_SEL:      T = Context->ObjCBuiltinSelTy;   break;
4066    case PREDEF_TYPE_AUTO_DEDUCT:   T = Context->getAutoDeductType(); break;
4067
4068    case PREDEF_TYPE_AUTO_RREF_DEDUCT:
4069      T = Context->getAutoRRefDeductType();
4070      break;
4071    }
4072
4073    assert(!T.isNull() && "Unknown predefined type");
4074    return T.withFastQualifiers(FastQuals);
4075  }
4076
4077  Index -= NUM_PREDEF_TYPE_IDS;
4078  assert(Index < TypesLoaded.size() && "Type index out-of-range");
4079  if (TypesLoaded[Index].isNull()) {
4080    TypesLoaded[Index] = readTypeRecord(Index);
4081    if (TypesLoaded[Index].isNull())
4082      return QualType();
4083
4084    TypesLoaded[Index]->setFromAST();
4085    if (DeserializationListener)
4086      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
4087                                        TypesLoaded[Index]);
4088  }
4089
4090  return TypesLoaded[Index].withFastQualifiers(FastQuals);
4091}
4092
4093QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
4094  return GetType(getGlobalTypeID(F, LocalID));
4095}
4096
4097serialization::TypeID
4098ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
4099  unsigned FastQuals = LocalID & Qualifiers::FastMask;
4100  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
4101
4102  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
4103    return LocalID;
4104
4105  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4106    = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
4107  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
4108
4109  unsigned GlobalIndex = LocalIndex + I->second;
4110  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
4111}
4112
4113TemplateArgumentLocInfo
4114ASTReader::GetTemplateArgumentLocInfo(Module &F,
4115                                      TemplateArgument::ArgKind Kind,
4116                                      const RecordData &Record,
4117                                      unsigned &Index) {
4118  switch (Kind) {
4119  case TemplateArgument::Expression:
4120    return ReadExpr(F);
4121  case TemplateArgument::Type:
4122    return GetTypeSourceInfo(F, Record, Index);
4123  case TemplateArgument::Template: {
4124    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4125                                                                     Index);
4126    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4127    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4128                                   SourceLocation());
4129  }
4130  case TemplateArgument::TemplateExpansion: {
4131    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4132                                                                     Index);
4133    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4134    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
4135    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4136                                   EllipsisLoc);
4137  }
4138  case TemplateArgument::Null:
4139  case TemplateArgument::Integral:
4140  case TemplateArgument::Declaration:
4141  case TemplateArgument::Pack:
4142    return TemplateArgumentLocInfo();
4143  }
4144  llvm_unreachable("unexpected template argument loc");
4145  return TemplateArgumentLocInfo();
4146}
4147
4148TemplateArgumentLoc
4149ASTReader::ReadTemplateArgumentLoc(Module &F,
4150                                   const RecordData &Record, unsigned &Index) {
4151  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
4152
4153  if (Arg.getKind() == TemplateArgument::Expression) {
4154    if (Record[Index++]) // bool InfoHasSameExpr.
4155      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
4156  }
4157  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
4158                                                             Record, Index));
4159}
4160
4161Decl *ASTReader::GetExternalDecl(uint32_t ID) {
4162  return GetDecl(ID);
4163}
4164
4165uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record,
4166                                          unsigned &Idx){
4167  if (Idx >= Record.size())
4168    return 0;
4169
4170  unsigned LocalID = Record[Idx++];
4171  return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
4172}
4173
4174CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
4175  RecordLocation Loc = getLocalBitOffset(Offset);
4176  llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
4177  SavedStreamPosition SavedPosition(Cursor);
4178  Cursor.JumpToBit(Loc.Offset);
4179  ReadingKindTracker ReadingKind(Read_Decl, *this);
4180  RecordData Record;
4181  unsigned Code = Cursor.ReadCode();
4182  unsigned RecCode = Cursor.ReadRecord(Code, Record);
4183  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
4184    Error("Malformed AST file: missing C++ base specifiers");
4185    return 0;
4186  }
4187
4188  unsigned Idx = 0;
4189  unsigned NumBases = Record[Idx++];
4190  void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
4191  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
4192  for (unsigned I = 0; I != NumBases; ++I)
4193    Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
4194  return Bases;
4195}
4196
4197serialization::DeclID
4198ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
4199  if (LocalID < NUM_PREDEF_DECL_IDS)
4200    return LocalID;
4201
4202  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4203    = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
4204  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
4205
4206  return LocalID + I->second;
4207}
4208
4209Decl *ASTReader::GetDecl(DeclID ID) {
4210  if (ID < NUM_PREDEF_DECL_IDS) {
4211    switch ((PredefinedDeclIDs)ID) {
4212    case PREDEF_DECL_NULL_ID:
4213      return 0;
4214
4215    case PREDEF_DECL_TRANSLATION_UNIT_ID:
4216      assert(Context && "No context available?");
4217      return Context->getTranslationUnitDecl();
4218
4219    case PREDEF_DECL_OBJC_ID_ID:
4220      assert(Context && "No context available?");
4221      return Context->getObjCIdDecl();
4222
4223    case PREDEF_DECL_OBJC_CLASS_ID:
4224      assert(Context && "No context available?");
4225      return Context->getObjCClassDecl();
4226    }
4227
4228    return 0;
4229  }
4230
4231  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
4232
4233  if (Index > DeclsLoaded.size()) {
4234    Error("declaration ID out-of-range for AST file");
4235    return 0;
4236  }
4237
4238if (!DeclsLoaded[Index]) {
4239    ReadDeclRecord(ID);
4240    if (DeserializationListener)
4241      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
4242  }
4243
4244  return DeclsLoaded[Index];
4245}
4246
4247serialization::DeclID ASTReader::ReadDeclID(Module &F,
4248                                            const RecordData &Record,
4249                                            unsigned &Idx) {
4250  if (Idx >= Record.size()) {
4251    Error("Corrupted AST file");
4252    return 0;
4253  }
4254
4255  return getGlobalDeclID(F, Record[Idx++]);
4256}
4257
4258/// \brief Resolve the offset of a statement into a statement.
4259///
4260/// This operation will read a new statement from the external
4261/// source each time it is called, and is meant to be used via a
4262/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
4263Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
4264  // Switch case IDs are per Decl.
4265  ClearSwitchCaseIDs();
4266
4267  // Offset here is a global offset across the entire chain.
4268  RecordLocation Loc = getLocalBitOffset(Offset);
4269  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
4270  return ReadStmtFromStream(*Loc.F);
4271}
4272
4273ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4274                                         bool (*isKindWeWant)(Decl::Kind),
4275                                         SmallVectorImpl<Decl*> &Decls) {
4276  // There might be lexical decls in multiple parts of the chain, for the TU
4277  // at least.
4278  // DeclContextOffsets might reallocate as we load additional decls below,
4279  // so make a copy of the vector.
4280  DeclContextInfos Infos = DeclContextOffsets[DC];
4281  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4282       I != E; ++I) {
4283    // IDs can be 0 if this context doesn't contain declarations.
4284    if (!I->LexicalDecls)
4285      continue;
4286
4287    // Load all of the declaration IDs
4288    for (const KindDeclIDPair *ID = I->LexicalDecls,
4289                              *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
4290      if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
4291        continue;
4292
4293      Decl *D = GetLocalDecl(*I->F, ID->second);
4294      assert(D && "Null decl in lexical decls");
4295      Decls.push_back(D);
4296    }
4297  }
4298
4299  ++NumLexicalDeclContextsRead;
4300  return ELR_Success;
4301}
4302
4303DeclContext::lookup_result
4304ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4305                                          DeclarationName Name) {
4306  assert(DC->hasExternalVisibleStorage() &&
4307         "DeclContext has no visible decls in storage");
4308  if (!Name)
4309    return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4310                                      DeclContext::lookup_iterator(0));
4311
4312  SmallVector<NamedDecl *, 64> Decls;
4313  // There might be visible decls in multiple parts of the chain, for the TU
4314  // and namespaces. For any given name, the last available results replace
4315  // all earlier ones. For this reason, we walk in reverse.
4316  // Copy the DeclContextInfos vector instead of using a reference to the
4317  // vector stored in the map, because DeclContextOffsets can change while
4318  // we load declarations with GetLocalDeclAs.
4319  DeclContextInfos Infos = DeclContextOffsets[DC];
4320  for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
4321       I != E; ++I) {
4322    if (!I->NameLookupTableData)
4323      continue;
4324
4325    ASTDeclContextNameLookupTable *LookupTable =
4326        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4327    ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
4328    if (Pos == LookupTable->end())
4329      continue;
4330
4331    ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4332    for (; Data.first != Data.second; ++Data.first) {
4333      NamedDecl *ND = GetLocalDeclAs<NamedDecl>(*I->F, *Data.first);
4334      if (!ND)
4335        continue;
4336
4337      if (ND->getDeclName() != Name) {
4338        assert(!Name.getCXXNameType().isNull() &&
4339               "Name mismatch without a type");
4340        continue;
4341      }
4342
4343      Decls.push_back(ND);
4344    }
4345
4346    // If we rejected all of the declarations we found, e.g., because the
4347    // name didn't actually match, continue looking through DeclContexts.
4348    if (Decls.empty())
4349      continue;
4350
4351    break;
4352  }
4353
4354  ++NumVisibleDeclContextsRead;
4355
4356  SetExternalVisibleDeclsForName(DC, Name, Decls);
4357  return const_cast<DeclContext*>(DC)->lookup(Name);
4358}
4359
4360void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
4361  assert(DC->hasExternalVisibleStorage() &&
4362         "DeclContext has no visible decls in storage");
4363
4364  SmallVector<NamedDecl *, 64> Decls;
4365  // There might be visible decls in multiple parts of the chain, for the TU
4366  // and namespaces.
4367  DeclContextInfos &Infos = DeclContextOffsets[DC];
4368  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4369       I != E; ++I) {
4370    if (!I->NameLookupTableData)
4371      continue;
4372
4373    ASTDeclContextNameLookupTable *LookupTable =
4374        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4375    for (ASTDeclContextNameLookupTable::item_iterator
4376           ItemI = LookupTable->item_begin(),
4377           ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
4378      ASTDeclContextNameLookupTable::item_iterator::value_type Val
4379          = *ItemI;
4380      ASTDeclContextNameLookupTrait::data_type Data = Val.second;
4381      Decls.clear();
4382      for (; Data.first != Data.second; ++Data.first)
4383        Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
4384      MaterializeVisibleDeclsForName(DC, Val.first, Decls);
4385    }
4386  }
4387}
4388
4389void ASTReader::PassInterestingDeclsToConsumer() {
4390  assert(Consumer);
4391  while (!InterestingDecls.empty()) {
4392    DeclGroupRef DG(InterestingDecls.front());
4393    InterestingDecls.pop_front();
4394    Consumer->HandleInterestingDecl(DG);
4395  }
4396}
4397
4398void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
4399  this->Consumer = Consumer;
4400
4401  if (!Consumer)
4402    return;
4403
4404  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
4405    // Force deserialization of this decl, which will cause it to be queued for
4406    // passing to the consumer.
4407    GetDecl(ExternalDefinitions[I]);
4408  }
4409
4410  PassInterestingDeclsToConsumer();
4411}
4412
4413void ASTReader::PrintStats() {
4414  std::fprintf(stderr, "*** AST File Statistics:\n");
4415
4416  unsigned NumTypesLoaded
4417    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
4418                                      QualType());
4419  unsigned NumDeclsLoaded
4420    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4421                                      (Decl *)0);
4422  unsigned NumIdentifiersLoaded
4423    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4424                                            IdentifiersLoaded.end(),
4425                                            (IdentifierInfo *)0);
4426  unsigned NumSelectorsLoaded
4427    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4428                                          SelectorsLoaded.end(),
4429                                          Selector());
4430
4431  std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
4432  std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
4433  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
4434    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
4435                 NumSLocEntriesRead, TotalNumSLocEntries,
4436                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4437  if (!TypesLoaded.empty())
4438    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4439                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4440                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4441  if (!DeclsLoaded.empty())
4442    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4443                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4444                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4445  if (!IdentifiersLoaded.empty())
4446    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4447                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4448                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4449  if (!SelectorsLoaded.empty())
4450    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4451                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4452                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4453  if (TotalNumStatements)
4454    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4455                 NumStatementsRead, TotalNumStatements,
4456                 ((float)NumStatementsRead/TotalNumStatements * 100));
4457  if (TotalNumMacros)
4458    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4459                 NumMacrosRead, TotalNumMacros,
4460                 ((float)NumMacrosRead/TotalNumMacros * 100));
4461  if (TotalLexicalDeclContexts)
4462    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4463                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4464                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4465                  * 100));
4466  if (TotalVisibleDeclContexts)
4467    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4468                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4469                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4470                  * 100));
4471  if (TotalNumMethodPoolEntries) {
4472    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4473                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4474                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4475                  * 100));
4476    std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4477  }
4478  std::fprintf(stderr, "\n");
4479  dump();
4480  std::fprintf(stderr, "\n");
4481}
4482
4483template<typename Key, typename Module, unsigned InitialCapacity>
4484static void
4485dumpModuleIDMap(StringRef Name,
4486                const ContinuousRangeMap<Key, Module *,
4487                                         InitialCapacity> &Map) {
4488  if (Map.begin() == Map.end())
4489    return;
4490
4491  typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
4492  llvm::errs() << Name << ":\n";
4493  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4494       I != IEnd; ++I) {
4495    llvm::errs() << "  " << I->first << " -> " << I->second->FileName
4496      << "\n";
4497  }
4498}
4499
4500void ASTReader::dump() {
4501  llvm::errs() << "*** PCH/Module Remappings:\n";
4502  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
4503  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
4504  dumpModuleIDMap("Global type map", GlobalTypeMap);
4505  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
4506  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
4507  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
4508  dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap);
4509  dumpModuleIDMap("Global preprocessed entity map",
4510                  GlobalPreprocessedEntityMap);
4511
4512  llvm::errs() << "\n*** PCH/Modules Loaded:";
4513  for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
4514                                       MEnd = ModuleMgr.end();
4515       M != MEnd; ++M)
4516    (*M)->dump();
4517}
4518
4519/// Return the amount of memory used by memory buffers, breaking down
4520/// by heap-backed versus mmap'ed memory.
4521void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4522  for (ModuleConstIterator I = ModuleMgr.begin(),
4523      E = ModuleMgr.end(); I != E; ++I) {
4524    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
4525      size_t bytes = buf->getBufferSize();
4526      switch (buf->getBufferKind()) {
4527        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4528          sizes.malloc_bytes += bytes;
4529          break;
4530        case llvm::MemoryBuffer::MemoryBuffer_MMap:
4531          sizes.mmap_bytes += bytes;
4532          break;
4533      }
4534    }
4535  }
4536}
4537
4538void ASTReader::InitializeSema(Sema &S) {
4539  SemaObj = &S;
4540  S.ExternalSource = this;
4541
4542  // Makes sure any declarations that were deserialized "too early"
4543  // still get added to the identifier's declaration chains.
4544  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4545    if (SemaObj->TUScope)
4546      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4547
4548    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4549  }
4550  PreloadedDecls.clear();
4551
4552  // Load the offsets of the declarations that Sema references.
4553  // They will be lazily deserialized when needed.
4554  if (!SemaDeclRefs.empty()) {
4555    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4556    if (!SemaObj->StdNamespace)
4557      SemaObj->StdNamespace = SemaDeclRefs[0];
4558    if (!SemaObj->StdBadAlloc)
4559      SemaObj->StdBadAlloc = SemaDeclRefs[1];
4560  }
4561
4562  if (!FPPragmaOptions.empty()) {
4563    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4564    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4565  }
4566
4567  if (!OpenCLExtensions.empty()) {
4568    unsigned I = 0;
4569#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4570#include "clang/Basic/OpenCLExtensions.def"
4571
4572    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4573  }
4574}
4575
4576IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4577  // Try to find this name within our on-disk hash tables. We start with the
4578  // most recent one, since that one contains the most up-to-date info.
4579  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4580    ASTIdentifierLookupTable *IdTable
4581        = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable;
4582    if (!IdTable)
4583      continue;
4584    std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
4585    ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
4586    if (Pos == IdTable->end())
4587      continue;
4588
4589    // Dereferencing the iterator has the effect of building the
4590    // IdentifierInfo node and populating it with the various
4591    // declarations it needs.
4592    return *Pos;
4593  }
4594  return 0;
4595}
4596
4597namespace clang {
4598  /// \brief An identifier-lookup iterator that enumerates all of the
4599  /// identifiers stored within a set of AST files.
4600  class ASTIdentifierIterator : public IdentifierIterator {
4601    /// \brief The AST reader whose identifiers are being enumerated.
4602    const ASTReader &Reader;
4603
4604    /// \brief The current index into the chain of AST files stored in
4605    /// the AST reader.
4606    unsigned Index;
4607
4608    /// \brief The current position within the identifier lookup table
4609    /// of the current AST file.
4610    ASTIdentifierLookupTable::key_iterator Current;
4611
4612    /// \brief The end position within the identifier lookup table of
4613    /// the current AST file.
4614    ASTIdentifierLookupTable::key_iterator End;
4615
4616  public:
4617    explicit ASTIdentifierIterator(const ASTReader &Reader);
4618
4619    virtual StringRef Next();
4620  };
4621}
4622
4623ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4624  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
4625  ASTIdentifierLookupTable *IdTable
4626    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
4627  Current = IdTable->key_begin();
4628  End = IdTable->key_end();
4629}
4630
4631StringRef ASTIdentifierIterator::Next() {
4632  while (Current == End) {
4633    // If we have exhausted all of our AST files, we're done.
4634    if (Index == 0)
4635      return StringRef();
4636
4637    --Index;
4638    ASTIdentifierLookupTable *IdTable
4639      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4640        IdentifierLookupTable;
4641    Current = IdTable->key_begin();
4642    End = IdTable->key_end();
4643  }
4644
4645  // We have any identifiers remaining in the current AST file; return
4646  // the next one.
4647  std::pair<const char*, unsigned> Key = *Current;
4648  ++Current;
4649  return StringRef(Key.first, Key.second);
4650}
4651
4652IdentifierIterator *ASTReader::getIdentifiers() const {
4653  return new ASTIdentifierIterator(*this);
4654}
4655
4656std::pair<ObjCMethodList, ObjCMethodList>
4657ASTReader::ReadMethodPool(Selector Sel) {
4658  // Find this selector in a hash table. We want to find the most recent entry.
4659  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4660    Module &F = *(*I);
4661    if (!F.SelectorLookupTable)
4662      continue;
4663
4664    ASTSelectorLookupTable *PoolTable
4665      = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4666    ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
4667    if (Pos != PoolTable->end()) {
4668      ++NumSelectorsRead;
4669      // FIXME: Not quite happy with the statistics here. We probably should
4670      // disable this tracking when called via LoadSelector.
4671      // Also, should entries without methods count as misses?
4672      ++NumMethodPoolEntriesRead;
4673      ASTSelectorLookupTrait::data_type Data = *Pos;
4674      if (DeserializationListener)
4675        DeserializationListener->SelectorRead(Data.ID, Sel);
4676      return std::make_pair(Data.Instance, Data.Factory);
4677    }
4678  }
4679
4680  ++NumMethodPoolMisses;
4681  return std::pair<ObjCMethodList, ObjCMethodList>();
4682}
4683
4684void ASTReader::ReadKnownNamespaces(
4685                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4686  Namespaces.clear();
4687
4688  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4689    if (NamespaceDecl *Namespace
4690                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4691      Namespaces.push_back(Namespace);
4692  }
4693}
4694
4695void ASTReader::ReadTentativeDefinitions(
4696                  SmallVectorImpl<VarDecl *> &TentativeDefs) {
4697  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4698    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
4699    if (Var)
4700      TentativeDefs.push_back(Var);
4701  }
4702  TentativeDefinitions.clear();
4703}
4704
4705void ASTReader::ReadUnusedFileScopedDecls(
4706                               SmallVectorImpl<const DeclaratorDecl *> &Decls) {
4707  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4708    DeclaratorDecl *D
4709      = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4710    if (D)
4711      Decls.push_back(D);
4712  }
4713  UnusedFileScopedDecls.clear();
4714}
4715
4716void ASTReader::ReadDelegatingConstructors(
4717                                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
4718  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4719    CXXConstructorDecl *D
4720      = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4721    if (D)
4722      Decls.push_back(D);
4723  }
4724  DelegatingCtorDecls.clear();
4725}
4726
4727void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
4728  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
4729    TypedefNameDecl *D
4730      = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
4731    if (D)
4732      Decls.push_back(D);
4733  }
4734  ExtVectorDecls.clear();
4735}
4736
4737void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
4738  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
4739    CXXRecordDecl *D
4740      = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
4741    if (D)
4742      Decls.push_back(D);
4743  }
4744  DynamicClasses.clear();
4745}
4746
4747void
4748ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
4749  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4750    NamedDecl *D
4751      = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4752    if (D)
4753      Decls.push_back(D);
4754  }
4755  LocallyScopedExternalDecls.clear();
4756}
4757
4758void ASTReader::ReadReferencedSelectors(
4759       SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
4760  if (ReferencedSelectorsData.empty())
4761    return;
4762
4763  // If there are @selector references added them to its pool. This is for
4764  // implementation of -Wselector.
4765  unsigned int DataSize = ReferencedSelectorsData.size()-1;
4766  unsigned I = 0;
4767  while (I < DataSize) {
4768    Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
4769    SourceLocation SelLoc
4770      = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
4771    Sels.push_back(std::make_pair(Sel, SelLoc));
4772  }
4773  ReferencedSelectorsData.clear();
4774}
4775
4776void ASTReader::ReadWeakUndeclaredIdentifiers(
4777       SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
4778  if (WeakUndeclaredIdentifiers.empty())
4779    return;
4780
4781  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
4782    IdentifierInfo *WeakId
4783      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4784    IdentifierInfo *AliasId
4785      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4786    SourceLocation Loc
4787      = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
4788    bool Used = WeakUndeclaredIdentifiers[I++];
4789    WeakInfo WI(AliasId, Loc);
4790    WI.setUsed(Used);
4791    WeakIDs.push_back(std::make_pair(WeakId, WI));
4792  }
4793  WeakUndeclaredIdentifiers.clear();
4794}
4795
4796void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
4797  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
4798    ExternalVTableUse VT;
4799    VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4800    VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
4801    VT.DefinitionRequired = VTableUses[Idx++];
4802    VTables.push_back(VT);
4803  }
4804
4805  VTableUses.clear();
4806}
4807
4808void ASTReader::ReadPendingInstantiations(
4809       SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
4810  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
4811    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
4812    SourceLocation Loc
4813      = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
4814    Pending.push_back(std::make_pair(D, Loc));
4815  }
4816  PendingInstantiations.clear();
4817}
4818
4819void ASTReader::LoadSelector(Selector Sel) {
4820  // It would be complicated to avoid reading the methods anyway. So don't.
4821  ReadMethodPool(Sel);
4822}
4823
4824void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
4825  assert(ID && "Non-zero identifier ID required");
4826  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4827  IdentifiersLoaded[ID - 1] = II;
4828  if (DeserializationListener)
4829    DeserializationListener->IdentifierRead(ID, II);
4830}
4831
4832/// \brief Set the globally-visible declarations associated with the given
4833/// identifier.
4834///
4835/// If the AST reader is currently in a state where the given declaration IDs
4836/// cannot safely be resolved, they are queued until it is safe to resolve
4837/// them.
4838///
4839/// \param II an IdentifierInfo that refers to one or more globally-visible
4840/// declarations.
4841///
4842/// \param DeclIDs the set of declaration IDs with the name @p II that are
4843/// visible at global scope.
4844///
4845/// \param Nonrecursive should be true to indicate that the caller knows that
4846/// this call is non-recursive, and therefore the globally-visible declarations
4847/// will not be placed onto the pending queue.
4848void
4849ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4850                              const SmallVectorImpl<uint32_t> &DeclIDs,
4851                                   bool Nonrecursive) {
4852  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4853    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4854    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4855    PII.II = II;
4856    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4857    return;
4858  }
4859
4860  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4861    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4862    if (SemaObj) {
4863      if (SemaObj->TUScope) {
4864        // Introduce this declaration into the translation-unit scope
4865        // and add it to the declaration chain for this identifier, so
4866        // that (unqualified) name lookup will find it.
4867        SemaObj->TUScope->AddDecl(D);
4868      }
4869      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4870    } else {
4871      // Queue this declaration so that it will be added to the
4872      // translation unit scope and identifier's declaration chain
4873      // once a Sema object is known.
4874      PreloadedDecls.push_back(D);
4875    }
4876  }
4877}
4878
4879IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
4880  if (ID == 0)
4881    return 0;
4882
4883  if (IdentifiersLoaded.empty()) {
4884    Error("no identifier table in AST file");
4885    return 0;
4886  }
4887
4888  assert(PP && "Forgot to set Preprocessor ?");
4889  ID -= 1;
4890  if (!IdentifiersLoaded[ID]) {
4891    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4892    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
4893    Module *M = I->second;
4894    unsigned Index = ID - M->BaseIdentifierID;
4895    const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
4896
4897    // All of the strings in the AST file are preceded by a 16-bit length.
4898    // Extract that 16-bit length to avoid having to execute strlen().
4899    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4900    //  unsigned integers.  This is important to avoid integer overflow when
4901    //  we cast them to 'unsigned'.
4902    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4903    unsigned StrLen = (((unsigned) StrLenPtr[0])
4904                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4905    IdentifiersLoaded[ID]
4906      = &PP->getIdentifierTable().get(StringRef(Str, StrLen));
4907    if (DeserializationListener)
4908      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4909  }
4910
4911  return IdentifiersLoaded[ID];
4912}
4913
4914IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
4915  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
4916}
4917
4918IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
4919  if (LocalID < NUM_PREDEF_IDENT_IDS)
4920    return LocalID;
4921
4922  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4923    = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
4924  assert(I != M.IdentifierRemap.end()
4925         && "Invalid index into identifier index remap");
4926
4927  return LocalID + I->second;
4928}
4929
4930bool ASTReader::ReadSLocEntry(int ID) {
4931  return ReadSLocEntryRecord(ID) != Success;
4932}
4933
4934Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
4935  return DecodeSelector(getGlobalSelectorID(M, LocalID));
4936}
4937
4938Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
4939  if (ID == 0)
4940    return Selector();
4941
4942  if (ID > SelectorsLoaded.size()) {
4943    Error("selector ID out of range in AST file");
4944    return Selector();
4945  }
4946
4947  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4948    // Load this selector from the selector table.
4949    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4950    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
4951    Module &M = *I->second;
4952    ASTSelectorLookupTrait Trait(*this, M);
4953    unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
4954    SelectorsLoaded[ID - 1] =
4955      Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
4956    if (DeserializationListener)
4957      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4958  }
4959
4960  return SelectorsLoaded[ID - 1];
4961}
4962
4963Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
4964  return DecodeSelector(ID);
4965}
4966
4967uint32_t ASTReader::GetNumExternalSelectors() {
4968  // ID 0 (the null selector) is considered an external selector.
4969  return getTotalNumSelectors() + 1;
4970}
4971
4972serialization::SelectorID
4973ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const {
4974  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
4975    return LocalID;
4976
4977  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4978    = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
4979  assert(I != M.SelectorRemap.end()
4980         && "Invalid index into identifier index remap");
4981
4982  return LocalID + I->second;
4983}
4984
4985DeclarationName
4986ASTReader::ReadDeclarationName(Module &F,
4987                               const RecordData &Record, unsigned &Idx) {
4988  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4989  switch (Kind) {
4990  case DeclarationName::Identifier:
4991    return DeclarationName(GetIdentifierInfo(F, Record, Idx));
4992
4993  case DeclarationName::ObjCZeroArgSelector:
4994  case DeclarationName::ObjCOneArgSelector:
4995  case DeclarationName::ObjCMultiArgSelector:
4996    return DeclarationName(ReadSelector(F, Record, Idx));
4997
4998  case DeclarationName::CXXConstructorName:
4999    return Context->DeclarationNames.getCXXConstructorName(
5000                          Context->getCanonicalType(readType(F, Record, Idx)));
5001
5002  case DeclarationName::CXXDestructorName:
5003    return Context->DeclarationNames.getCXXDestructorName(
5004                          Context->getCanonicalType(readType(F, Record, Idx)));
5005
5006  case DeclarationName::CXXConversionFunctionName:
5007    return Context->DeclarationNames.getCXXConversionFunctionName(
5008                          Context->getCanonicalType(readType(F, Record, Idx)));
5009
5010  case DeclarationName::CXXOperatorName:
5011    return Context->DeclarationNames.getCXXOperatorName(
5012                                       (OverloadedOperatorKind)Record[Idx++]);
5013
5014  case DeclarationName::CXXLiteralOperatorName:
5015    return Context->DeclarationNames.getCXXLiteralOperatorName(
5016                                       GetIdentifierInfo(F, Record, Idx));
5017
5018  case DeclarationName::CXXUsingDirective:
5019    return DeclarationName::getUsingDirectiveName();
5020  }
5021
5022  // Required to silence GCC warning
5023  return DeclarationName();
5024}
5025
5026void ASTReader::ReadDeclarationNameLoc(Module &F,
5027                                       DeclarationNameLoc &DNLoc,
5028                                       DeclarationName Name,
5029                                      const RecordData &Record, unsigned &Idx) {
5030  switch (Name.getNameKind()) {
5031  case DeclarationName::CXXConstructorName:
5032  case DeclarationName::CXXDestructorName:
5033  case DeclarationName::CXXConversionFunctionName:
5034    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
5035    break;
5036
5037  case DeclarationName::CXXOperatorName:
5038    DNLoc.CXXOperatorName.BeginOpNameLoc
5039        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5040    DNLoc.CXXOperatorName.EndOpNameLoc
5041        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5042    break;
5043
5044  case DeclarationName::CXXLiteralOperatorName:
5045    DNLoc.CXXLiteralOperatorName.OpNameLoc
5046        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5047    break;
5048
5049  case DeclarationName::Identifier:
5050  case DeclarationName::ObjCZeroArgSelector:
5051  case DeclarationName::ObjCOneArgSelector:
5052  case DeclarationName::ObjCMultiArgSelector:
5053  case DeclarationName::CXXUsingDirective:
5054    break;
5055  }
5056}
5057
5058void ASTReader::ReadDeclarationNameInfo(Module &F,
5059                                        DeclarationNameInfo &NameInfo,
5060                                      const RecordData &Record, unsigned &Idx) {
5061  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
5062  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
5063  DeclarationNameLoc DNLoc;
5064  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
5065  NameInfo.setInfo(DNLoc);
5066}
5067
5068void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
5069                                  const RecordData &Record, unsigned &Idx) {
5070  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
5071  unsigned NumTPLists = Record[Idx++];
5072  Info.NumTemplParamLists = NumTPLists;
5073  if (NumTPLists) {
5074    Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
5075    for (unsigned i=0; i != NumTPLists; ++i)
5076      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
5077  }
5078}
5079
5080TemplateName
5081ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
5082                            unsigned &Idx) {
5083  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
5084  switch (Kind) {
5085  case TemplateName::Template:
5086      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
5087
5088  case TemplateName::OverloadedTemplate: {
5089    unsigned size = Record[Idx++];
5090    UnresolvedSet<8> Decls;
5091    while (size--)
5092      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
5093
5094    return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
5095  }
5096
5097  case TemplateName::QualifiedTemplate: {
5098    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5099    bool hasTemplKeyword = Record[Idx++];
5100    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
5101    return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
5102  }
5103
5104  case TemplateName::DependentTemplate: {
5105    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5106    if (Record[Idx++])  // isIdentifier
5107      return Context->getDependentTemplateName(NNS,
5108                                               GetIdentifierInfo(F, Record,
5109                                                                 Idx));
5110    return Context->getDependentTemplateName(NNS,
5111                                         (OverloadedOperatorKind)Record[Idx++]);
5112  }
5113
5114  case TemplateName::SubstTemplateTemplateParm: {
5115    TemplateTemplateParmDecl *param
5116      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5117    if (!param) return TemplateName();
5118    TemplateName replacement = ReadTemplateName(F, Record, Idx);
5119    return Context->getSubstTemplateTemplateParm(param, replacement);
5120  }
5121
5122  case TemplateName::SubstTemplateTemplateParmPack: {
5123    TemplateTemplateParmDecl *Param
5124      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5125    if (!Param)
5126      return TemplateName();
5127
5128    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
5129    if (ArgPack.getKind() != TemplateArgument::Pack)
5130      return TemplateName();
5131
5132    return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
5133  }
5134  }
5135
5136  assert(0 && "Unhandled template name kind!");
5137  return TemplateName();
5138}
5139
5140TemplateArgument
5141ASTReader::ReadTemplateArgument(Module &F,
5142                                const RecordData &Record, unsigned &Idx) {
5143  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
5144  switch (Kind) {
5145  case TemplateArgument::Null:
5146    return TemplateArgument();
5147  case TemplateArgument::Type:
5148    return TemplateArgument(readType(F, Record, Idx));
5149  case TemplateArgument::Declaration:
5150    return TemplateArgument(ReadDecl(F, Record, Idx));
5151  case TemplateArgument::Integral: {
5152    llvm::APSInt Value = ReadAPSInt(Record, Idx);
5153    QualType T = readType(F, Record, Idx);
5154    return TemplateArgument(Value, T);
5155  }
5156  case TemplateArgument::Template:
5157    return TemplateArgument(ReadTemplateName(F, Record, Idx));
5158  case TemplateArgument::TemplateExpansion: {
5159    TemplateName Name = ReadTemplateName(F, Record, Idx);
5160    llvm::Optional<unsigned> NumTemplateExpansions;
5161    if (unsigned NumExpansions = Record[Idx++])
5162      NumTemplateExpansions = NumExpansions - 1;
5163    return TemplateArgument(Name, NumTemplateExpansions);
5164  }
5165  case TemplateArgument::Expression:
5166    return TemplateArgument(ReadExpr(F));
5167  case TemplateArgument::Pack: {
5168    unsigned NumArgs = Record[Idx++];
5169    TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
5170    for (unsigned I = 0; I != NumArgs; ++I)
5171      Args[I] = ReadTemplateArgument(F, Record, Idx);
5172    return TemplateArgument(Args, NumArgs);
5173  }
5174  }
5175
5176  assert(0 && "Unhandled template argument kind!");
5177  return TemplateArgument();
5178}
5179
5180TemplateParameterList *
5181ASTReader::ReadTemplateParameterList(Module &F,
5182                                     const RecordData &Record, unsigned &Idx) {
5183  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
5184  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
5185  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
5186
5187  unsigned NumParams = Record[Idx++];
5188  SmallVector<NamedDecl *, 16> Params;
5189  Params.reserve(NumParams);
5190  while (NumParams--)
5191    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
5192
5193  TemplateParameterList* TemplateParams =
5194    TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
5195                                  Params.data(), Params.size(), RAngleLoc);
5196  return TemplateParams;
5197}
5198
5199void
5200ASTReader::
5201ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
5202                         Module &F, const RecordData &Record,
5203                         unsigned &Idx) {
5204  unsigned NumTemplateArgs = Record[Idx++];
5205  TemplArgs.reserve(NumTemplateArgs);
5206  while (NumTemplateArgs--)
5207    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
5208}
5209
5210/// \brief Read a UnresolvedSet structure.
5211void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
5212                                  const RecordData &Record, unsigned &Idx) {
5213  unsigned NumDecls = Record[Idx++];
5214  while (NumDecls--) {
5215    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
5216    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5217    Set.addDecl(D, AS);
5218  }
5219}
5220
5221CXXBaseSpecifier
5222ASTReader::ReadCXXBaseSpecifier(Module &F,
5223                                const RecordData &Record, unsigned &Idx) {
5224  bool isVirtual = static_cast<bool>(Record[Idx++]);
5225  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5226  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
5227  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
5228  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5229  SourceRange Range = ReadSourceRange(F, Record, Idx);
5230  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
5231  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
5232                          EllipsisLoc);
5233  Result.setInheritConstructors(inheritConstructors);
5234  return Result;
5235}
5236
5237std::pair<CXXCtorInitializer **, unsigned>
5238ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
5239                                   unsigned &Idx) {
5240  CXXCtorInitializer **CtorInitializers = 0;
5241  unsigned NumInitializers = Record[Idx++];
5242  if (NumInitializers) {
5243    ASTContext &C = *getContext();
5244
5245    CtorInitializers
5246        = new (C) CXXCtorInitializer*[NumInitializers];
5247    for (unsigned i=0; i != NumInitializers; ++i) {
5248      TypeSourceInfo *BaseClassInfo = 0;
5249      bool IsBaseVirtual = false;
5250      FieldDecl *Member = 0;
5251      IndirectFieldDecl *IndirectMember = 0;
5252      CXXConstructorDecl *Target = 0;
5253
5254      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5255      switch (Type) {
5256       case CTOR_INITIALIZER_BASE:
5257        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
5258        IsBaseVirtual = Record[Idx++];
5259        break;
5260
5261       case CTOR_INITIALIZER_DELEGATING:
5262        Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
5263        break;
5264
5265       case CTOR_INITIALIZER_MEMBER:
5266        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
5267        break;
5268
5269       case CTOR_INITIALIZER_INDIRECT_MEMBER:
5270        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
5271        break;
5272      }
5273
5274      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
5275      Expr *Init = ReadExpr(F);
5276      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
5277      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
5278      bool IsWritten = Record[Idx++];
5279      unsigned SourceOrderOrNumArrayIndices;
5280      SmallVector<VarDecl *, 8> Indices;
5281      if (IsWritten) {
5282        SourceOrderOrNumArrayIndices = Record[Idx++];
5283      } else {
5284        SourceOrderOrNumArrayIndices = Record[Idx++];
5285        Indices.reserve(SourceOrderOrNumArrayIndices);
5286        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
5287          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
5288      }
5289
5290      CXXCtorInitializer *BOMInit;
5291      if (Type == CTOR_INITIALIZER_BASE) {
5292        BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
5293                                             LParenLoc, Init, RParenLoc,
5294                                             MemberOrEllipsisLoc);
5295      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5296        BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
5297                                             Target, Init, RParenLoc);
5298      } else if (IsWritten) {
5299        if (Member)
5300          BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
5301                                               LParenLoc, Init, RParenLoc);
5302        else
5303          BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
5304                                               MemberOrEllipsisLoc, LParenLoc,
5305                                               Init, RParenLoc);
5306      } else {
5307        BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
5308                                             LParenLoc, Init, RParenLoc,
5309                                             Indices.data(), Indices.size());
5310      }
5311
5312      if (IsWritten)
5313        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
5314      CtorInitializers[i] = BOMInit;
5315    }
5316  }
5317
5318  return std::make_pair(CtorInitializers, NumInitializers);
5319}
5320
5321NestedNameSpecifier *
5322ASTReader::ReadNestedNameSpecifier(Module &F,
5323                                   const RecordData &Record, unsigned &Idx) {
5324  unsigned N = Record[Idx++];
5325  NestedNameSpecifier *NNS = 0, *Prev = 0;
5326  for (unsigned I = 0; I != N; ++I) {
5327    NestedNameSpecifier::SpecifierKind Kind
5328      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5329    switch (Kind) {
5330    case NestedNameSpecifier::Identifier: {
5331      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5332      NNS = NestedNameSpecifier::Create(*Context, Prev, II);
5333      break;
5334    }
5335
5336    case NestedNameSpecifier::Namespace: {
5337      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5338      NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
5339      break;
5340    }
5341
5342    case NestedNameSpecifier::NamespaceAlias: {
5343      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5344      NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
5345      break;
5346    }
5347
5348    case NestedNameSpecifier::TypeSpec:
5349    case NestedNameSpecifier::TypeSpecWithTemplate: {
5350      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
5351      if (!T)
5352        return 0;
5353
5354      bool Template = Record[Idx++];
5355      NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
5356      break;
5357    }
5358
5359    case NestedNameSpecifier::Global: {
5360      NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
5361      // No associated value, and there can't be a prefix.
5362      break;
5363    }
5364    }
5365    Prev = NNS;
5366  }
5367  return NNS;
5368}
5369
5370NestedNameSpecifierLoc
5371ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
5372                                      unsigned &Idx) {
5373  unsigned N = Record[Idx++];
5374  NestedNameSpecifierLocBuilder Builder;
5375  for (unsigned I = 0; I != N; ++I) {
5376    NestedNameSpecifier::SpecifierKind Kind
5377      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5378    switch (Kind) {
5379    case NestedNameSpecifier::Identifier: {
5380      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5381      SourceRange Range = ReadSourceRange(F, Record, Idx);
5382      Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
5383      break;
5384    }
5385
5386    case NestedNameSpecifier::Namespace: {
5387      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5388      SourceRange Range = ReadSourceRange(F, Record, Idx);
5389      Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
5390      break;
5391    }
5392
5393    case NestedNameSpecifier::NamespaceAlias: {
5394      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5395      SourceRange Range = ReadSourceRange(F, Record, Idx);
5396      Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
5397      break;
5398    }
5399
5400    case NestedNameSpecifier::TypeSpec:
5401    case NestedNameSpecifier::TypeSpecWithTemplate: {
5402      bool Template = Record[Idx++];
5403      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5404      if (!T)
5405        return NestedNameSpecifierLoc();
5406      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5407
5408      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5409      Builder.Extend(*Context,
5410                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5411                     T->getTypeLoc(), ColonColonLoc);
5412      break;
5413    }
5414
5415    case NestedNameSpecifier::Global: {
5416      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5417      Builder.MakeGlobal(*Context, ColonColonLoc);
5418      break;
5419    }
5420    }
5421  }
5422
5423  return Builder.getWithLocInContext(*Context);
5424}
5425
5426SourceRange
5427ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
5428                           unsigned &Idx) {
5429  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5430  SourceLocation end = ReadSourceLocation(F, Record, Idx);
5431  return SourceRange(beg, end);
5432}
5433
5434/// \brief Read an integral value
5435llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5436  unsigned BitWidth = Record[Idx++];
5437  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5438  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5439  Idx += NumWords;
5440  return Result;
5441}
5442
5443/// \brief Read a signed integral value
5444llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5445  bool isUnsigned = Record[Idx++];
5446  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5447}
5448
5449/// \brief Read a floating-point value
5450llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5451  return llvm::APFloat(ReadAPInt(Record, Idx));
5452}
5453
5454// \brief Read a string
5455std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5456  unsigned Len = Record[Idx++];
5457  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5458  Idx += Len;
5459  return Result;
5460}
5461
5462VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5463                                         unsigned &Idx) {
5464  unsigned Major = Record[Idx++];
5465  unsigned Minor = Record[Idx++];
5466  unsigned Subminor = Record[Idx++];
5467  if (Minor == 0)
5468    return VersionTuple(Major);
5469  if (Subminor == 0)
5470    return VersionTuple(Major, Minor - 1);
5471  return VersionTuple(Major, Minor - 1, Subminor - 1);
5472}
5473
5474CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
5475                                          const RecordData &Record,
5476                                          unsigned &Idx) {
5477  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
5478  return CXXTemporary::Create(*Context, Decl);
5479}
5480
5481DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5482  return Diag(SourceLocation(), DiagID);
5483}
5484
5485DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5486  return Diags.Report(Loc, DiagID);
5487}
5488
5489/// \brief Retrieve the identifier table associated with the
5490/// preprocessor.
5491IdentifierTable &ASTReader::getIdentifierTable() {
5492  assert(PP && "Forgot to set Preprocessor ?");
5493  return PP->getIdentifierTable();
5494}
5495
5496/// \brief Record that the given ID maps to the given switch-case
5497/// statement.
5498void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5499  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5500  SwitchCaseStmts[ID] = SC;
5501}
5502
5503/// \brief Retrieve the switch-case statement with the given ID.
5504SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5505  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5506  return SwitchCaseStmts[ID];
5507}
5508
5509void ASTReader::ClearSwitchCaseIDs() {
5510  SwitchCaseStmts.clear();
5511}
5512
5513void ASTReader::FinishedDeserializing() {
5514  assert(NumCurrentElementsDeserializing &&
5515         "FinishedDeserializing not paired with StartedDeserializing");
5516  if (NumCurrentElementsDeserializing == 1) {
5517    // If any identifiers with corresponding top-level declarations have
5518    // been loaded, load those declarations now.
5519    while (!PendingIdentifierInfos.empty()) {
5520      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5521                              PendingIdentifierInfos.front().DeclIDs, true);
5522      PendingIdentifierInfos.pop_front();
5523    }
5524
5525    // Ready to load previous declarations of Decls that were delayed.
5526    while (!PendingPreviousDecls.empty()) {
5527      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5528                                PendingPreviousDecls.front().second);
5529      PendingPreviousDecls.pop_front();
5530    }
5531
5532    // We are not in recursive loading, so it's safe to pass the "interesting"
5533    // decls to the consumer.
5534    if (Consumer)
5535      PassInterestingDeclsToConsumer();
5536
5537    assert(PendingForwardRefs.size() == 0 &&
5538           "Some forward refs did not get linked to the definition!");
5539  }
5540  --NumCurrentElementsDeserializing;
5541}
5542
5543ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
5544                     StringRef isysroot, bool DisableValidation,
5545                     bool DisableStatCache)
5546  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5547    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5548    Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
5549    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5550    RelocatablePCH(false), isysroot(isysroot),
5551    DisableValidation(DisableValidation),
5552    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5553    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5554    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5555    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5556    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5557    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5558    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5559    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5560    NumCXXBaseSpecifiersLoaded(0)
5561{
5562  SourceMgr.setExternalSLocEntrySource(this);
5563}
5564
5565ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
5566                     Diagnostic &Diags, StringRef isysroot,
5567                     bool DisableValidation, bool DisableStatCache)
5568  : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
5569    Diags(Diags), SemaObj(0), PP(0), Context(0),
5570    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5571    RelocatablePCH(false), isysroot(isysroot),
5572    DisableValidation(DisableValidation), DisableStatCache(DisableStatCache),
5573    NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0),
5574    TotalNumSLocEntries(0), NumStatementsRead(0),
5575    TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
5576    NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
5577    TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
5578    TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
5579    TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0),
5580    NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0)
5581{
5582  SourceMgr.setExternalSLocEntrySource(this);
5583}
5584
5585ASTReader::~ASTReader() {
5586  // Delete all visible decl lookup tables
5587  for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5588                                       E = DeclContextOffsets.end();
5589       I != E; ++I) {
5590    for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5591         J != F; ++J) {
5592      if (J->NameLookupTableData)
5593        delete static_cast<ASTDeclContextNameLookupTable*>(
5594            J->NameLookupTableData);
5595    }
5596  }
5597  for (DeclContextVisibleUpdatesPending::iterator
5598           I = PendingVisibleUpdates.begin(),
5599           E = PendingVisibleUpdates.end();
5600       I != E; ++I) {
5601    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5602                                             F = I->second.end();
5603         J != F; ++J)
5604      delete static_cast<ASTDeclContextNameLookupTable*>(J->first);
5605  }
5606}
5607
5608Module::Module(ModuleKind Kind)
5609  : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0),
5610    SLocEntryBaseOffset(0), SLocEntryOffsets(0),
5611    SLocFileOffsets(0), LocalNumIdentifiers(0),
5612    IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0),
5613    IdentifierLookupTable(0), BasePreprocessedEntityID(0),
5614    LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0),
5615    BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0),
5616    HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
5617    HeaderFileFrameworkStrings(0),
5618    LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0),
5619    SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
5620    DeclOffsets(0), BaseDeclID(0),
5621    LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5622    LocalNumTypes(0), TypeOffsets(0), BaseTypeIndex(0), StatCache(0),
5623    NumPreallocatedPreprocessingEntities(0)
5624{}
5625
5626Module::~Module() {
5627  delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
5628  delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
5629  delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5630}
5631
5632template<typename Key, typename Offset, unsigned InitialCapacity>
5633static void
5634dumpLocalRemap(StringRef Name,
5635               const ContinuousRangeMap<Key, Offset, InitialCapacity> &Map) {
5636  if (Map.begin() == Map.end())
5637    return;
5638
5639  typedef ContinuousRangeMap<Key, Offset, InitialCapacity> MapType;
5640  llvm::errs() << "  " << Name << ":\n";
5641  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
5642       I != IEnd; ++I) {
5643    llvm::errs() << "    " << I->first << " -> " << I->second
5644    << "\n";
5645  }
5646}
5647
5648void Module::dump() {
5649  llvm::errs() << "\nModule: " << FileName << "\n";
5650  if (!Imports.empty()) {
5651    llvm::errs() << "  Imports: ";
5652    for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
5653      if (I)
5654        llvm::errs() << ", ";
5655      llvm::errs() << Imports[I]->FileName;
5656    }
5657    llvm::errs() << "\n";
5658  }
5659
5660  // Remapping tables.
5661  llvm::errs() << "  Base source location offset: " << SLocEntryBaseOffset
5662               << '\n';
5663  dumpLocalRemap("Source location offset local -> global map", SLocRemap);
5664
5665  llvm::errs() << "  Base identifier ID: " << BaseIdentifierID << '\n'
5666               << "  Number of identifiers: " << LocalNumIdentifiers << '\n';
5667  dumpLocalRemap("Identifier ID local -> global map", IdentifierRemap);
5668
5669  llvm::errs() << "  Base selector ID: " << BaseSelectorID << '\n'
5670               << "  Number of selectors: " << LocalNumSelectors << '\n';
5671  dumpLocalRemap("Selector ID local -> global map", SelectorRemap);
5672
5673  llvm::errs() << "  Base preprocessed entity ID: " << BasePreprocessedEntityID
5674               << '\n'
5675               << "  Number of preprocessed entities: "
5676               << NumPreallocatedPreprocessingEntities << '\n';
5677  dumpLocalRemap("Preprocessed entity ID local -> global map",
5678                 PreprocessedEntityRemap);
5679
5680  llvm::errs() << "  Base macro definition ID: " << BaseMacroDefinitionID
5681               << '\n'
5682               << "  Number of macro definitions: " << LocalNumMacroDefinitions
5683               << '\n';
5684  dumpLocalRemap("Macro definition ID local -> global map",
5685                 MacroDefinitionRemap);
5686
5687  llvm::errs() << "  Base type index: " << BaseTypeIndex << '\n'
5688               << "  Number of types: " << LocalNumTypes << '\n';
5689  dumpLocalRemap("Type index local -> global map", TypeRemap);
5690
5691  llvm::errs() << "  Base decl ID: " << BaseDeclID << '\n'
5692               << "  Number of decls: " << LocalNumDecls << '\n';
5693  dumpLocalRemap("Decl ID local -> global map", DeclRemap);
5694}
5695
5696Module *ModuleManager::lookup(StringRef Name) {
5697  const FileEntry *Entry = FileMgr.getFile(Name);
5698  return Modules[Entry];
5699}
5700
5701llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) {
5702  const FileEntry *Entry = FileMgr.getFile(Name);
5703  return InMemoryBuffers[Entry];
5704}
5705
5706/// \brief Creates a new module and adds it to the list of known modules
5707Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) {
5708  Module *Prev = !size() ? 0 : &getLastModule();
5709  Module *Current = new Module(Type);
5710
5711  Current->FileName = FileName.str();
5712
5713  Chain.push_back(Current);
5714  const FileEntry *Entry = FileMgr.getFile(FileName);
5715  Modules[Entry] = Current;
5716
5717  if (Prev) {
5718    Current->ImportedBy.insert(Prev);
5719    Prev->Imports.insert(Current);
5720  }
5721
5722  return *Current;
5723}
5724
5725void ModuleManager::addInMemoryBuffer(StringRef FileName,
5726  llvm::MemoryBuffer *Buffer) {
5727
5728  const FileEntry *Entry = FileMgr.getVirtualFile(FileName,
5729    Buffer->getBufferSize(), 0);
5730  InMemoryBuffers[Entry] = Buffer;
5731}
5732/// \brief Exports the list of loaded modules with their corresponding names
5733void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) {
5734  Target.reserve(size());
5735  for (ModuleConstIterator I = Chain.begin(), E = Chain.end();
5736       I != E; ++I) {
5737    Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset,
5738                                  (*I)->FileName));
5739  }
5740  std::sort(Target.begin(), Target.end());
5741}
5742
5743ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { }
5744
5745ModuleManager::~ModuleManager() {
5746  for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5747    delete Chain[e - i - 1];
5748}
5749