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