Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@170431 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 6992 insertions, 6998 deletions

diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp
index 88b5614124..c0976ee1e6 100644
--- a/lib/Serialization/ASTReader.cpp
+++ b/lib/Serialization/ASTReader.cpp
@@ -1,6998 +1,6992 @@
-//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===//

-//

-//                     The LLVM Compiler Infrastructure

-//

-// This file is distributed under the University of Illinois Open Source

-// License. See LICENSE.TXT for details.

-//

-//===----------------------------------------------------------------------===//

-//

-//  This file defines the ASTReader class, which reads AST files.

-//

-//===----------------------------------------------------------------------===//

-

-#include "clang/Serialization/ASTReader.h"

-#include "ASTCommon.h"

-#include "ASTReaderInternals.h"

-#include "clang/AST/ASTConsumer.h"

-#include "clang/AST/ASTContext.h"

-#include "clang/AST/DeclTemplate.h"

-#include "clang/AST/Expr.h"

-#include "clang/AST/ExprCXX.h"

-#include "clang/AST/NestedNameSpecifier.h"

-#include "clang/AST/Type.h"

-#include "clang/AST/TypeLocVisitor.h"

-#include "clang/Basic/FileManager.h"

-#include "clang/Basic/FileSystemStatCache.h"

-#include "clang/Basic/OnDiskHashTable.h"

-#include "clang/Basic/SourceManager.h"

-#include "clang/Basic/SourceManagerInternals.h"

-#include "clang/Basic/TargetInfo.h"

-#include "clang/Basic/TargetOptions.h"

-#include "clang/Basic/Version.h"

-#include "clang/Basic/VersionTuple.h"

-#include "clang/Lex/HeaderSearch.h"

-#include "clang/Lex/HeaderSearchOptions.h"

-#include "clang/Lex/MacroInfo.h"

-#include "clang/Lex/PreprocessingRecord.h"

-#include "clang/Lex/Preprocessor.h"

-#include "clang/Lex/PreprocessorOptions.h"

-#include "clang/Sema/Scope.h"

-#include "clang/Sema/Sema.h"

-#include "clang/Serialization/ASTDeserializationListener.h"

-#include "clang/Serialization/ModuleManager.h"

-#include "clang/Serialization/SerializationDiagnostic.h"

-#include "llvm/ADT/StringExtras.h"

-#include "llvm/Bitcode/BitstreamReader.h"

-#include "llvm/Support/ErrorHandling.h"

-#include "llvm/Support/FileSystem.h"

-#include "llvm/Support/MemoryBuffer.h"

-#include "llvm/Support/Path.h"

-#include "llvm/Support/SaveAndRestore.h"

-#include "llvm/Support/system_error.h"

-#include <algorithm>

-#include <cstdio>

-#include <iterator>

-

-using namespace clang;

-using namespace clang::serialization;

-using namespace clang::serialization::reader;

-

-//===----------------------------------------------------------------------===//

-// PCH validator implementation

-//===----------------------------------------------------------------------===//

-

-ASTReaderListener::~ASTReaderListener() {}

-

-/// \brief Compare the given set of language options against an existing set of

-/// language options.

-///

-/// \param Diags If non-NULL, diagnostics will be emitted via this engine.

-///

-/// \returns true if the languagae options mis-match, false otherwise.

-static bool checkLanguageOptions(const LangOptions &LangOpts,

-                                 const LangOptions &ExistingLangOpts,

-                                 DiagnosticsEngine *Diags) {

-#define LANGOPT(Name, Bits, Default, Description)                 \

-  if (ExistingLangOpts.Name != LangOpts.Name) {                   \

-    if (Diags)                                                    \

-      Diags->Report(diag::err_pch_langopt_mismatch)               \

-        << Description << LangOpts.Name << ExistingLangOpts.Name; \

-    return true;                                                  \

-  }

-

-#define VALUE_LANGOPT(Name, Bits, Default, Description)   \

-  if (ExistingLangOpts.Name != LangOpts.Name) {           \

-    if (Diags)                                            \

-      Diags->Report(diag::err_pch_langopt_value_mismatch) \

-        << Description;                                   \

-    return true;                                          \

-  }

-

-#define ENUM_LANGOPT(Name, Type, Bits, Default, Description)   \

-  if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) {  \

-    if (Diags)                                                 \

-      Diags->Report(diag::err_pch_langopt_value_mismatch)      \

-        << Description;                                        \

-    return true;                                               \

-  }

-

-#define BENIGN_LANGOPT(Name, Bits, Default, Description)

-#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)

-#include "clang/Basic/LangOptions.def"

-

-  if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {

-    if (Diags)

-      Diags->Report(diag::err_pch_langopt_value_mismatch)

-      << "target Objective-C runtime";

-    return true;

-  }

-

-  return false;

-}

-

-/// \brief Compare the given set of target options against an existing set of

-/// target options.

-///

-/// \param Diags If non-NULL, diagnostics will be emitted via this engine.

-///

-/// \returns true if the target options mis-match, false otherwise.

-static bool checkTargetOptions(const TargetOptions &TargetOpts,

-                               const TargetOptions &ExistingTargetOpts,

-                               DiagnosticsEngine *Diags) {

-#define CHECK_TARGET_OPT(Field, Name)                             \

-  if (TargetOpts.Field != ExistingTargetOpts.Field) {             \

-    if (Diags)                                                    \

-      Diags->Report(diag::err_pch_targetopt_mismatch)             \

-        << Name << TargetOpts.Field << ExistingTargetOpts.Field;  \

-    return true;                                                  \

-  }

-

-  CHECK_TARGET_OPT(Triple, "target");

-  CHECK_TARGET_OPT(CPU, "target CPU");

-  CHECK_TARGET_OPT(ABI, "target ABI");

-  CHECK_TARGET_OPT(CXXABI, "target C++ ABI");

-  CHECK_TARGET_OPT(LinkerVersion, "target linker version");

-#undef CHECK_TARGET_OPT

-

-  // Compare feature sets.

-  SmallVector<StringRef, 4> ExistingFeatures(

-                                             ExistingTargetOpts.FeaturesAsWritten.begin(),

-                                             ExistingTargetOpts.FeaturesAsWritten.end());

-  SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),

-                                         TargetOpts.FeaturesAsWritten.end());

-  std::sort(ExistingFeatures.begin(), ExistingFeatures.end());

-  std::sort(ReadFeatures.begin(), ReadFeatures.end());

-

-  unsigned ExistingIdx = 0, ExistingN = ExistingFeatures.size();

-  unsigned ReadIdx = 0, ReadN = ReadFeatures.size();

-  while (ExistingIdx < ExistingN && ReadIdx < ReadN) {

-    if (ExistingFeatures[ExistingIdx] == ReadFeatures[ReadIdx]) {

-      ++ExistingIdx;

-      ++ReadIdx;

-      continue;

-    }

-

-    if (ReadFeatures[ReadIdx] < ExistingFeatures[ExistingIdx]) {

-      if (Diags)

-        Diags->Report(diag::err_pch_targetopt_feature_mismatch)

-          << false << ReadFeatures[ReadIdx];

-      return true;

-    }

-

-    if (Diags)

-      Diags->Report(diag::err_pch_targetopt_feature_mismatch)

-        << true << ExistingFeatures[ExistingIdx];

-    return true;

-  }

-

-  if (ExistingIdx < ExistingN) {

-    if (Diags)

-      Diags->Report(diag::err_pch_targetopt_feature_mismatch)

-        << true << ExistingFeatures[ExistingIdx];

-    return true;

-  }

-

-  if (ReadIdx < ReadN) {

-    if (Diags)

-      Diags->Report(diag::err_pch_targetopt_feature_mismatch)

-        << false << ReadFeatures[ReadIdx];

-    return true;

-  }

-

-  return false;

-}

-

-bool

-PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,

-                                  bool Complain) {

-  const LangOptions &ExistingLangOpts = PP.getLangOpts();

-  return checkLanguageOptions(LangOpts, ExistingLangOpts,

-                              Complain? &Reader.Diags : 0);

-}

-

-bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,

-                                     bool Complain) {

-  const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();

-  return checkTargetOptions(TargetOpts, ExistingTargetOpts,

-                            Complain? &Reader.Diags : 0);

-}

-

-namespace {

-  typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >

-    MacroDefinitionsMap;

-}

-

-/// \brief Collect the macro definitions provided by the given preprocessor

-/// options.

-static void collectMacroDefinitions(const PreprocessorOptions &PPOpts,

-                                    MacroDefinitionsMap &Macros,

-                                    SmallVectorImpl<StringRef> *MacroNames = 0){

-  for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {

-    StringRef Macro = PPOpts.Macros[I].first;

-    bool IsUndef = PPOpts.Macros[I].second;

-

-    std::pair<StringRef, StringRef> MacroPair = Macro.split('=');

-    StringRef MacroName = MacroPair.first;

-    StringRef MacroBody = MacroPair.second;

-

-    // For an #undef'd macro, we only care about the name.

-    if (IsUndef) {

-      if (MacroNames && !Macros.count(MacroName))

-        MacroNames->push_back(MacroName);

-

-      Macros[MacroName] = std::make_pair("", true);

-      continue;

-    }

-

-    // For a #define'd macro, figure out the actual definition.

-    if (MacroName.size() == Macro.size())

-      MacroBody = "1";

-    else {

-      // Note: GCC drops anything following an end-of-line character.

-      StringRef::size_type End = MacroBody.find_first_of("\n\r");

-      MacroBody = MacroBody.substr(0, End);

-    }

-

-    if (MacroNames && !Macros.count(MacroName))

-      MacroNames->push_back(MacroName);

-    Macros[MacroName] = std::make_pair(MacroBody, false);

-  }

-}

-         

-/// \brief Check the preprocessor options deserialized from the control block

-/// against the preprocessor options in an existing preprocessor.

-///

-/// \param Diags If non-null, produce diagnostics for any mismatches incurred.

-static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,

-                                     const PreprocessorOptions &ExistingPPOpts,

-                                     DiagnosticsEngine *Diags,

-                                     FileManager &FileMgr,

-                                     std::string &SuggestedPredefines) {

-  // Check macro definitions.

-  MacroDefinitionsMap ASTFileMacros;

-  collectMacroDefinitions(PPOpts, ASTFileMacros);

-  MacroDefinitionsMap ExistingMacros;

-  SmallVector<StringRef, 4> ExistingMacroNames;

-  collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);

-

-  for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {

-    // Dig out the macro definition in the existing preprocessor options.

-    StringRef MacroName = ExistingMacroNames[I];

-    std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];

-

-    // Check whether we know anything about this macro name or not.

-    llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known

-      = ASTFileMacros.find(MacroName);

-    if (Known == ASTFileMacros.end()) {

-      // FIXME: Check whether this identifier was referenced anywhere in the

-      // AST file. If so, we should reject the AST file. Unfortunately, this

-      // information isn't in the control block. What shall we do about it?

-

-      if (Existing.second) {

-        SuggestedPredefines += "#undef ";

-        SuggestedPredefines += MacroName.str();

-        SuggestedPredefines += '\n';

-      } else {

-        SuggestedPredefines += "#define ";

-        SuggestedPredefines += MacroName.str();

-        SuggestedPredefines += ' ';

-        SuggestedPredefines += Existing.first.str();

-        SuggestedPredefines += '\n';

-      }

-      continue;

-    }

-

-    // If the macro was defined in one but undef'd in the other, we have a

-    // conflict.

-    if (Existing.second != Known->second.second) {

-      if (Diags) {

-        Diags->Report(diag::err_pch_macro_def_undef)

-          << MacroName << Known->second.second;

-      }

-      return true;

-    }

-

-    // If the macro was #undef'd in both, or if the macro bodies are identical,

-    // it's fine.

-    if (Existing.second || Existing.first == Known->second.first)

-      continue;

-

-    // The macro bodies differ; complain.

-    if (Diags) {

-      Diags->Report(diag::err_pch_macro_def_conflict)

-        << MacroName << Known->second.first << Existing.first;

-    }

-    return true;

-  }

-

-  // Check whether we're using predefines.

-  if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) {

-    if (Diags) {

-      Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;

-    }

-    return true;

-  }

-

-  // Compute the #include and #include_macros lines we need.

-  for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {

-    StringRef File = ExistingPPOpts.Includes[I];

-    if (File == ExistingPPOpts.ImplicitPCHInclude)

-      continue;

-

-    if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)

-          != PPOpts.Includes.end())

-      continue;

-

-    SuggestedPredefines += "#include \"";

-    SuggestedPredefines +=

-      HeaderSearch::NormalizeDashIncludePath(File, FileMgr);

-    SuggestedPredefines += "\"\n";

-  }

-

-  for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {

-    StringRef File = ExistingPPOpts.MacroIncludes[I];

-    if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),

-                  File)

-        != PPOpts.MacroIncludes.end())

-      continue;

-

-    SuggestedPredefines += "#__include_macros \"";

-    SuggestedPredefines +=

-      HeaderSearch::NormalizeDashIncludePath(File, FileMgr);

-    SuggestedPredefines += "\"\n##\n";

-  }

-

-  return false;

-}

-

-bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,

-                                           bool Complain,

-                                           std::string &SuggestedPredefines) {

-  const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();

-

-  return checkPreprocessorOptions(PPOpts, ExistingPPOpts,

-                                  Complain? &Reader.Diags : 0,

-                                  PP.getFileManager(),

-                                  SuggestedPredefines);

-}

-

-void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,

-                                      unsigned ID) {

-  PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);

-  ++NumHeaderInfos;

-}

-

-void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {

-  PP.setCounterValue(Value);

-}

-

-//===----------------------------------------------------------------------===//

-// AST reader implementation

-//===----------------------------------------------------------------------===//

-

-void

-ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {

-  DeserializationListener = Listener;

-}

-

-

-

-unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {

-  return serialization::ComputeHash(Sel);

-}

-

-

-std::pair<unsigned, unsigned>

-ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {

-  using namespace clang::io;

-  unsigned KeyLen = ReadUnalignedLE16(d);

-  unsigned DataLen = ReadUnalignedLE16(d);

-  return std::make_pair(KeyLen, DataLen);

-}

-

-ASTSelectorLookupTrait::internal_key_type 

-ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {

-  using namespace clang::io;

-  SelectorTable &SelTable = Reader.getContext().Selectors;

-  unsigned N = ReadUnalignedLE16(d);

-  IdentifierInfo *FirstII

-    = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));

-  if (N == 0)

-    return SelTable.getNullarySelector(FirstII);

-  else if (N == 1)

-    return SelTable.getUnarySelector(FirstII);

-

-  SmallVector<IdentifierInfo *, 16> Args;

-  Args.push_back(FirstII);

-  for (unsigned I = 1; I != N; ++I)

-    Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)));

-

-  return SelTable.getSelector(N, Args.data());

-}

-

-ASTSelectorLookupTrait::data_type 

-ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d, 

-                                 unsigned DataLen) {

-  using namespace clang::io;

-

-  data_type Result;

-

-  Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));

-  unsigned NumInstanceMethods = ReadUnalignedLE16(d);

-  unsigned NumFactoryMethods = ReadUnalignedLE16(d);

-

-  // Load instance methods

-  for (unsigned I = 0; I != NumInstanceMethods; ++I) {

-    if (ObjCMethodDecl *Method

-          = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))

-      Result.Instance.push_back(Method);

-  }

-

-  // Load factory methods

-  for (unsigned I = 0; I != NumFactoryMethods; ++I) {

-    if (ObjCMethodDecl *Method

-          = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))

-      Result.Factory.push_back(Method);

-  }

-

-  return Result;

-}

-

-unsigned ASTIdentifierLookupTrait::ComputeHash(const internal_key_type& a) {

-  return llvm::HashString(StringRef(a.first, a.second));

-}

-

-std::pair<unsigned, unsigned>

-ASTIdentifierLookupTrait::ReadKeyDataLength(const unsigned char*& d) {

-  using namespace clang::io;

-  unsigned DataLen = ReadUnalignedLE16(d);

-  unsigned KeyLen = ReadUnalignedLE16(d);

-  return std::make_pair(KeyLen, DataLen);

-}

-

-std::pair<const char*, unsigned>

-ASTIdentifierLookupTrait::ReadKey(const unsigned char* d, unsigned n) {

-  assert(n >= 2 && d[n-1] == '\0');

-  return std::make_pair((const char*) d, n-1);

-}

-

-IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,

-                                                   const unsigned char* d,

-                                                   unsigned DataLen) {

-  using namespace clang::io;

-  unsigned RawID = ReadUnalignedLE32(d);

-  bool IsInteresting = RawID & 0x01;

-

-  // Wipe out the "is interesting" bit.

-  RawID = RawID >> 1;

-

-  IdentID ID = Reader.getGlobalIdentifierID(F, RawID);

-  if (!IsInteresting) {

-    // For uninteresting identifiers, just build the IdentifierInfo

-    // and associate it with the persistent ID.

-    IdentifierInfo *II = KnownII;

-    if (!II) {

-      II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));

-      KnownII = II;

-    }

-    Reader.SetIdentifierInfo(ID, II);

-    II->setIsFromAST();

-    Reader.markIdentifierUpToDate(II);    

-    return II;

-  }

-

-  unsigned ObjCOrBuiltinID = ReadUnalignedLE16(d);

-  unsigned Bits = ReadUnalignedLE16(d);

-  bool CPlusPlusOperatorKeyword = Bits & 0x01;

-  Bits >>= 1;

-  bool HasRevertedTokenIDToIdentifier = Bits & 0x01;

-  Bits >>= 1;

-  bool Poisoned = Bits & 0x01;

-  Bits >>= 1;

-  bool ExtensionToken = Bits & 0x01;

-  Bits >>= 1;

-  bool hadMacroDefinition = Bits & 0x01;

-  Bits >>= 1;

-

-  assert(Bits == 0 && "Extra bits in the identifier?");

-  DataLen -= 8;

-

-  // Build the IdentifierInfo itself and link the identifier ID with

-  // the new IdentifierInfo.

-  IdentifierInfo *II = KnownII;

-  if (!II) {

-    II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));

-    KnownII = II;

-  }

-  Reader.markIdentifierUpToDate(II);

-  II->setIsFromAST();

-

-  // Set or check the various bits in the IdentifierInfo structure.

-  // Token IDs are read-only.

-  if (HasRevertedTokenIDToIdentifier)

-    II->RevertTokenIDToIdentifier();

-  II->setObjCOrBuiltinID(ObjCOrBuiltinID);

-  assert(II->isExtensionToken() == ExtensionToken &&

-         "Incorrect extension token flag");

-  (void)ExtensionToken;

-  if (Poisoned)

-    II->setIsPoisoned(true);

-  assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&

-         "Incorrect C++ operator keyword flag");

-  (void)CPlusPlusOperatorKeyword;

-

-  // If this identifier is a macro, deserialize the macro

-  // definition.

-  if (hadMacroDefinition) {

-    SmallVector<MacroID, 4> MacroIDs;

-    while (uint32_t LocalID = ReadUnalignedLE32(d)) {

-      MacroIDs.push_back(Reader.getGlobalMacroID(F, LocalID));

-      DataLen -= 4;

-    }

-    DataLen -= 4;

-    Reader.setIdentifierIsMacro(II, MacroIDs);

-  }

-

-  Reader.SetIdentifierInfo(ID, II);

-

-  // Read all of the declarations visible at global scope with this

-  // name.

-  if (DataLen > 0) {

-    SmallVector<uint32_t, 4> DeclIDs;

-    for (; DataLen > 0; DataLen -= 4)

-      DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d)));

-    Reader.SetGloballyVisibleDecls(II, DeclIDs);

-  }

-

-  return II;

-}

-

-unsigned 

-ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const {

-  llvm::FoldingSetNodeID ID;

-  ID.AddInteger(Key.Kind);

-

-  switch (Key.Kind) {

-  case DeclarationName::Identifier:

-  case DeclarationName::CXXLiteralOperatorName:

-    ID.AddString(((IdentifierInfo*)Key.Data)->getName());

-    break;

-  case DeclarationName::ObjCZeroArgSelector:

-  case DeclarationName::ObjCOneArgSelector:

-  case DeclarationName::ObjCMultiArgSelector:

-    ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));

-    break;

-  case DeclarationName::CXXOperatorName:

-    ID.AddInteger((OverloadedOperatorKind)Key.Data);

-    break;

-  case DeclarationName::CXXConstructorName:

-  case DeclarationName::CXXDestructorName:

-  case DeclarationName::CXXConversionFunctionName:

-  case DeclarationName::CXXUsingDirective:

-    break;

-  }

-

-  return ID.ComputeHash();

-}

-

-ASTDeclContextNameLookupTrait::internal_key_type 

-ASTDeclContextNameLookupTrait::GetInternalKey(

-                                          const external_key_type& Name) const {

-  DeclNameKey Key;

-  Key.Kind = Name.getNameKind();

-  switch (Name.getNameKind()) {

-  case DeclarationName::Identifier:

-    Key.Data = (uint64_t)Name.getAsIdentifierInfo();

-    break;

-  case DeclarationName::ObjCZeroArgSelector:

-  case DeclarationName::ObjCOneArgSelector:

-  case DeclarationName::ObjCMultiArgSelector:

-    Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();

-    break;

-  case DeclarationName::CXXOperatorName:

-    Key.Data = Name.getCXXOverloadedOperator();

-    break;

-  case DeclarationName::CXXLiteralOperatorName:

-    Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();

-    break;

-  case DeclarationName::CXXConstructorName:

-  case DeclarationName::CXXDestructorName:

-  case DeclarationName::CXXConversionFunctionName:

-  case DeclarationName::CXXUsingDirective:

-    Key.Data = 0;

-    break;

-  }

-

-  return Key;

-}

-

-std::pair<unsigned, unsigned>

-ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) {

-  using namespace clang::io;

-  unsigned KeyLen = ReadUnalignedLE16(d);

-  unsigned DataLen = ReadUnalignedLE16(d);

-  return std::make_pair(KeyLen, DataLen);

-}

-

-ASTDeclContextNameLookupTrait::internal_key_type 

-ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) {

-  using namespace clang::io;

-

-  DeclNameKey Key;

-  Key.Kind = (DeclarationName::NameKind)*d++;

-  switch (Key.Kind) {

-  case DeclarationName::Identifier:

-    Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));

-    break;

-  case DeclarationName::ObjCZeroArgSelector:

-  case DeclarationName::ObjCOneArgSelector:

-  case DeclarationName::ObjCMultiArgSelector:

-    Key.Data =

-       (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d))

-                   .getAsOpaquePtr();

-    break;

-  case DeclarationName::CXXOperatorName:

-    Key.Data = *d++; // OverloadedOperatorKind

-    break;

-  case DeclarationName::CXXLiteralOperatorName:

-    Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));

-    break;

-  case DeclarationName::CXXConstructorName:

-  case DeclarationName::CXXDestructorName:

-  case DeclarationName::CXXConversionFunctionName:

-  case DeclarationName::CXXUsingDirective:

-    Key.Data = 0;

-    break;

-  }

-

-  return Key;

-}

-

-ASTDeclContextNameLookupTrait::data_type 

-ASTDeclContextNameLookupTrait::ReadData(internal_key_type, 

-                                        const unsigned char* d,

-                                        unsigned DataLen) {

-  using namespace clang::io;

-  unsigned NumDecls = ReadUnalignedLE16(d);

-  LE32DeclID *Start = (LE32DeclID *)d;

-  return std::make_pair(Start, Start + NumDecls);

-}

-

-bool ASTReader::ReadDeclContextStorage(ModuleFile &M,

-                                       llvm::BitstreamCursor &Cursor,

-                                   const std::pair<uint64_t, uint64_t> &Offsets,

-                                       DeclContextInfo &Info) {

-  SavedStreamPosition SavedPosition(Cursor);

-  // First the lexical decls.

-  if (Offsets.first != 0) {

-    Cursor.JumpToBit(Offsets.first);

-

-    RecordData Record;

-    const char *Blob;

-    unsigned BlobLen;

-    unsigned Code = Cursor.ReadCode();

-    unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);

-    if (RecCode != DECL_CONTEXT_LEXICAL) {

-      Error("Expected lexical block");

-      return true;

-    }

-

-    Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);

-    Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);

-  }

-

-  // Now the lookup table.

-  if (Offsets.second != 0) {

-    Cursor.JumpToBit(Offsets.second);

-

-    RecordData Record;

-    const char *Blob;

-    unsigned BlobLen;

-    unsigned Code = Cursor.ReadCode();

-    unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);

-    if (RecCode != DECL_CONTEXT_VISIBLE) {

-      Error("Expected visible lookup table block");

-      return true;

-    }

-    Info.NameLookupTableData

-      = ASTDeclContextNameLookupTable::Create(

-                    (const unsigned char *)Blob + Record[0],

-                    (const unsigned char *)Blob,

-                    ASTDeclContextNameLookupTrait(*this, M));

-  }

-

-  return false;

-}

-

-void ASTReader::Error(StringRef Msg) {

-  Error(diag::err_fe_pch_malformed, Msg);

-}

-

-void ASTReader::Error(unsigned DiagID,

-                      StringRef Arg1, StringRef Arg2) {

-  if (Diags.isDiagnosticInFlight())

-    Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);

-  else

-    Diag(DiagID) << Arg1 << Arg2;

-}

-

-//===----------------------------------------------------------------------===//

-// Source Manager Deserialization

-//===----------------------------------------------------------------------===//

-

-/// \brief Read the line table in the source manager block.

-/// \returns true if there was an error.

-bool ASTReader::ParseLineTable(ModuleFile &F,

-                               SmallVectorImpl<uint64_t> &Record) {

-  unsigned Idx = 0;

-  LineTableInfo &LineTable = SourceMgr.getLineTable();

-

-  // Parse the file names

-  std::map<int, int> FileIDs;

-  for (int I = 0, N = Record[Idx++]; I != N; ++I) {

-    // Extract the file name

-    unsigned FilenameLen = Record[Idx++];

-    std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);

-    Idx += FilenameLen;

-    MaybeAddSystemRootToFilename(F, Filename);

-    FileIDs[I] = LineTable.getLineTableFilenameID(Filename);

-  }

-

-  // Parse the line entries

-  std::vector<LineEntry> Entries;

-  while (Idx < Record.size()) {

-    int FID = Record[Idx++];

-    assert(FID >= 0 && "Serialized line entries for non-local file.");

-    // Remap FileID from 1-based old view.

-    FID += F.SLocEntryBaseID - 1;

-

-    // Extract the line entries

-    unsigned NumEntries = Record[Idx++];

-    assert(NumEntries && "Numentries is 00000");

-    Entries.clear();

-    Entries.reserve(NumEntries);

-    for (unsigned I = 0; I != NumEntries; ++I) {

-      unsigned FileOffset = Record[Idx++];

-      unsigned LineNo = Record[Idx++];

-      int FilenameID = FileIDs[Record[Idx++]];

-      SrcMgr::CharacteristicKind FileKind

-        = (SrcMgr::CharacteristicKind)Record[Idx++];

-      unsigned IncludeOffset = Record[Idx++];

-      Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,

-                                       FileKind, IncludeOffset));

-    }

-    LineTable.AddEntry(FileID::get(FID), Entries);

-  }

-

-  return false;

-}

-

-/// \brief Read a source manager block

-bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {

-  using namespace SrcMgr;

-

-  llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;

-

-  // Set the source-location entry cursor to the current position in

-  // the stream. This cursor will be used to read the contents of the

-  // source manager block initially, and then lazily read

-  // source-location entries as needed.

-  SLocEntryCursor = F.Stream;

-

-  // The stream itself is going to skip over the source manager block.

-  if (F.Stream.SkipBlock()) {

-    Error("malformed block record in AST file");

-    return true;

-  }

-

-  // Enter the source manager block.

-  if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {

-    Error("malformed source manager block record in AST file");

-    return true;

-  }

-

-  RecordData Record;

-  while (true) {

-    unsigned Code = SLocEntryCursor.ReadCode();

-    if (Code == llvm::bitc::END_BLOCK) {

-      if (SLocEntryCursor.ReadBlockEnd()) {

-        Error("error at end of Source Manager block in AST file");

-        return true;

-      }

-      return false;

-    }

-

-    if (Code == llvm::bitc::ENTER_SUBBLOCK) {

-      // No known subblocks, always skip them.

-      SLocEntryCursor.ReadSubBlockID();

-      if (SLocEntryCursor.SkipBlock()) {

-        Error("malformed block record in AST file");

-        return true;

-      }

-      continue;

-    }

-

-    if (Code == llvm::bitc::DEFINE_ABBREV) {

-      SLocEntryCursor.ReadAbbrevRecord();

-      continue;

-    }

-

-    // Read a record.

-    const char *BlobStart;

-    unsigned BlobLen;

-    Record.clear();

-    switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {

-    default:  // Default behavior: ignore.

-      break;

-

-    case SM_SLOC_FILE_ENTRY:

-    case SM_SLOC_BUFFER_ENTRY:

-    case SM_SLOC_EXPANSION_ENTRY:

-      // Once we hit one of the source location entries, we're done.

-      return false;

-    }

-  }

-}

-

-/// \brief If a header file is not found at the path that we expect it to be

-/// and the PCH file was moved from its original location, try to resolve the

-/// file by assuming that header+PCH were moved together and the header is in

-/// the same place relative to the PCH.

-static std::string

-resolveFileRelativeToOriginalDir(const std::string &Filename,

-                                 const std::string &OriginalDir,

-                                 const std::string &CurrDir) {

-  assert(OriginalDir != CurrDir &&

-         "No point trying to resolve the file if the PCH dir didn't change");

-  using namespace llvm::sys;

-  SmallString<128> filePath(Filename);

-  fs::make_absolute(filePath);

-  assert(path::is_absolute(OriginalDir));

-  SmallString<128> currPCHPath(CurrDir);

-

-  path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),

-                       fileDirE = path::end(path::parent_path(filePath));

-  path::const_iterator origDirI = path::begin(OriginalDir),

-                       origDirE = path::end(OriginalDir);

-  // Skip the common path components from filePath and OriginalDir.

-  while (fileDirI != fileDirE && origDirI != origDirE &&

-         *fileDirI == *origDirI) {

-    ++fileDirI;

-    ++origDirI;

-  }

-  for (; origDirI != origDirE; ++origDirI)

-    path::append(currPCHPath, "..");

-  path::append(currPCHPath, fileDirI, fileDirE);

-  path::append(currPCHPath, path::filename(Filename));

-  return currPCHPath.str();

-}

-

-bool ASTReader::ReadSLocEntry(int ID) {

-  if (ID == 0)

-    return false;

-

-  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {

-    Error("source location entry ID out-of-range for AST file");

-    return true;

-  }

-

-  ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;

-  F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);

-  llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;

-  unsigned BaseOffset = F->SLocEntryBaseOffset;

-

-  ++NumSLocEntriesRead;

-  unsigned Code = SLocEntryCursor.ReadCode();

-  if (Code == llvm::bitc::END_BLOCK ||

-      Code == llvm::bitc::ENTER_SUBBLOCK ||

-      Code == llvm::bitc::DEFINE_ABBREV) {

-    Error("incorrectly-formatted source location entry in AST file");

-    return true;

-  }

-

-  RecordData Record;

-  const char *BlobStart;

-  unsigned BlobLen;

-  switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {

-  default:

-    Error("incorrectly-formatted source location entry in AST file");

-    return true;

-

-  case SM_SLOC_FILE_ENTRY: {

-    // We will detect whether a file changed and return 'Failure' for it, but

-    // we will also try to fail gracefully by setting up the SLocEntry.

-    unsigned InputID = Record[4];

-    InputFile IF = getInputFile(*F, InputID);

-    const FileEntry *File = IF.getPointer();

-    bool OverriddenBuffer = IF.getInt();

-

-    if (!IF.getPointer())

-      return true;

-

-    SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);

-    if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {

-      // This is the module's main file.

-      IncludeLoc = getImportLocation(F);

-    }

-    SrcMgr::CharacteristicKind

-      FileCharacter = (SrcMgr::CharacteristicKind)Record[2];

-    FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,

-                                        ID, BaseOffset + Record[0]);

-    SrcMgr::FileInfo &FileInfo =

-          const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());

-    FileInfo.NumCreatedFIDs = Record[5];

-    if (Record[3])

-      FileInfo.setHasLineDirectives();

-

-    const DeclID *FirstDecl = F->FileSortedDecls + Record[6];

-    unsigned NumFileDecls = Record[7];

-    if (NumFileDecls) {

-      assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");

-      FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,

-                                                             NumFileDecls));

-    }

-    

-    const SrcMgr::ContentCache *ContentCache

-      = SourceMgr.getOrCreateContentCache(File,

-                              /*isSystemFile=*/FileCharacter != SrcMgr::C_User);

-    if (OverriddenBuffer && !ContentCache->BufferOverridden &&

-        ContentCache->ContentsEntry == ContentCache->OrigEntry) {

-      unsigned Code = SLocEntryCursor.ReadCode();

-      Record.clear();

-      unsigned RecCode

-        = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);

-      

-      if (RecCode != SM_SLOC_BUFFER_BLOB) {

-        Error("AST record has invalid code");

-        return true;

-      }

-      

-      llvm::MemoryBuffer *Buffer

-        = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),

-                                           File->getName());

-      SourceMgr.overrideFileContents(File, Buffer);

-    }

-

-    break;

-  }

-

-  case SM_SLOC_BUFFER_ENTRY: {

-    const char *Name = BlobStart;

-    unsigned Offset = Record[0];

-    SrcMgr::CharacteristicKind

-      FileCharacter = (SrcMgr::