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