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