Reduce PCH size by compressing SourceLocation sequences. Current savings are ~6%

clang/include/clang/Serialization/ASTReader.h

 #include "clang/Sema/ExternalSemaSource.h"
 #include "clang/Sema/IdentifierResolver.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Serialization/ContinuousRangeMap.h"
 #include "clang/Serialization/ModuleFile.h"
 #include "clang/Serialization/ModuleFileExtension.h"
 #include "clang/Serialization/ModuleManager.h"
+#include "clang/Serialization/SourceLocationEncoding.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
public:
 
   /// Read a AlignPackInfo from raw form.
   Sema::AlignPackInfo ReadAlignPackInfo(uint32_t Raw) const {
     return Sema::AlignPackInfo::getFromRawEncoding(Raw);
   }
 
   /// Read a source location from raw form and return it in its
   /// originating module file's source location space.
-  SourceLocation
-  ReadUntranslatedSourceLocation(SourceLocation::UIntTy Raw) const {
-    return SourceLocation::getFromRawEncoding((Raw >> 1) |
-                                              (Raw << (8 * sizeof(Raw) - 1)));
+  SourceLocation ReadUntranslatedSourceLocation(
+      uint64_t Raw, serialization::SourceLocationSeq *Seq = nullptr) const {
+    return Seq ? Seq->decode(Raw)
+               : SourceLocation::getFromRawEncoding(
+                     serialization::SourceLocations::decodeRaw(Raw));
   }
 
   /// Read a source location from raw form.
-  SourceLocation ReadSourceLocation(ModuleFile &ModuleFile,
-                                    SourceLocation::UIntTy Raw) const {
-    SourceLocation Loc = ReadUntranslatedSourceLocation(Raw);
+  SourceLocation
+  ReadSourceLocation(ModuleFile &ModuleFile, uint64_t Raw,
+                     serialization::SourceLocationSeq *Seq = nullptr) const {
+    SourceLocation Loc = ReadUntranslatedSourceLocation(Raw, Seq);
     return TranslateSourceLocation(ModuleFile, Loc);
   }
 
   /// Translate a source location from another module file's source
   /// location space into ours.
   SourceLocation TranslateSourceLocation(ModuleFile &ModuleFile,
                                          SourceLocation Loc) const {
     if (!ModuleFile.ModuleOffsetMap.empty())
       ReadModuleOffsetMap(ModuleFile);
     assert(ModuleFile.SLocRemap.find(Loc.getOffset()) !=
                ModuleFile.SLocRemap.end() &&
            "Cannot find offset to remap.");
     SourceLocation::IntTy Remap =
         ModuleFile.SLocRemap.find(Loc.getOffset())->second;
     return Loc.getLocWithOffset(Remap);
   }
 
   /// Read a source location.
-  SourceLocation ReadSourceLocation(ModuleFile &ModuleFile,
-                                    const RecordDataImpl &Record,
-                                    unsigned &Idx) {
-    return ReadSourceLocation(ModuleFile, Record[Idx++]);
+  SourceLocation
+  ReadSourceLocation(ModuleFile &ModuleFile, const RecordDataImpl &Record,
+                     unsigned &Idx,
+                     serialization::SourceLocationSeq *Seq = nullptr) {
+    return ReadSourceLocation(ModuleFile, Record[Idx++], Seq);
   }
 
   /// Read a source range.
-  SourceRange ReadSourceRange(ModuleFile &F,
-                              const RecordData &Record, unsigned &Idx);
+  SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record,
+                              unsigned &Idx,
+                              serialization::SourceLocationSeq *Seq = nullptr) {
+    SourceLocation beg = ReadSourceLocation(F, Record, Idx, Seq);
+    SourceLocation end = ReadSourceLocation(F, Record, Idx, Seq);
+    return SourceRange(beg, end);
+  }
 
   // Read a string
   static std::string ReadString(const RecordData &Record, unsigned &Idx);
 
   // Skip a string
   static void SkipString(const RecordData &Record, unsigned &Idx) {
     Idx += Record[Idx] + 1;
   }

clang/include/clang/Serialization/ASTRecordReader.h

public:
   template<typename T>
   T *GetLocalDeclAs(uint32_t LocalID) {
     return cast_or_null<T>(Reader->GetLocalDecl(*F, LocalID));
   }
 
   /// Reads a TemplateArgumentLocInfo appropriate for the
   /// given TemplateArgument kind, advancing Idx.
   TemplateArgumentLocInfo
-  readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind);
+  readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
+                              serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Reads a TemplateArgumentLoc, advancing Idx.
   TemplateArgumentLoc readTemplateArgumentLoc();
 
   const ASTTemplateArgumentListInfo*
   readASTTemplateArgumentListInfo();
 
   /// Reads a declarator info from the given record, advancing Idx.
-  TypeSourceInfo *readTypeSourceInfo();
+  TypeSourceInfo *readTypeSourceInfo(serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Reads the location information for a type.
-  void readTypeLoc(TypeLoc TL);
+  void readTypeLoc(TypeLoc TL, serialization::SourceLocationSeq *Seq = nullptr);
 
 
   /// Map a local type ID within a given AST file to a global type ID.
   serialization::TypeID getGlobalTypeID(unsigned LocalID) const {
     return Reader->getGlobalTypeID(*F, LocalID);
   }
 
   Qualifiers readQualifiers() {
public:
 
   /// Read a selector from the Record, advancing Idx.
   Selector readSelector() {
     return Reader->ReadSelector(*F, Record, Idx);
   }
 
   /// Read a declaration name, advancing Idx.
   // DeclarationName readDeclarationName(); (inherited)
-  DeclarationNameLoc readDeclarationNameLoc(DeclarationName Name);
+  DeclarationNameLoc
+  readDeclarationNameLoc(DeclarationName Name,
+                         serialization::SourceLocationSeq *Seq = nullptr);
   DeclarationNameInfo readDeclarationNameInfo();
 
-  void readQualifierInfo(QualifierInfo &Info);
+  void readQualifierInfo(QualifierInfo &Info,
+                         serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Return a nested name specifier, advancing Idx.
   // NestedNameSpecifier *readNestedNameSpecifier(); (inherited)
 
-  NestedNameSpecifierLoc readNestedNameSpecifierLoc();
+  NestedNameSpecifierLoc
+  readNestedNameSpecifierLoc(serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Read a template name, advancing Idx.
   // TemplateName readTemplateName(); (inherited)
 
   /// Read a template argument, advancing Idx. (inherited)
   // TemplateArgument readTemplateArgument();
   using DataStreamBasicReader::readTemplateArgument;
   TemplateArgument readTemplateArgument(bool Canonicalize) {
     TemplateArgument Arg = readTemplateArgument();
     if (Canonicalize) {
       Arg = getContext().getCanonicalTemplateArgument(Arg);
     }
     return Arg;
   }
 
   /// Read a template parameter list, advancing Idx.
-  TemplateParameterList *readTemplateParameterList();
+  TemplateParameterList *
+  readTemplateParameterList(serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Read a template argument array, advancing Idx.
   void readTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
                                 bool Canonicalize = false);
 
   /// Read a UnresolvedSet structure, advancing Idx.
   void readUnresolvedSet(LazyASTUnresolvedSet &Set);
 
public:
 
   /// Read an OpenMP clause, advancing Idx.
   OMPClause *readOMPClause();
 
   /// Read an OpenMP children, advancing Idx.
   void readOMPChildren(OMPChildren *Data);
 
   /// Read a source location, advancing Idx.
-  SourceLocation readSourceLocation() {
-    return Reader->ReadSourceLocation(*F, Record, Idx);
+  SourceLocation
+  readSourceLocation(serialization::SourceLocationSeq *Seq = nullptr) {
+    return Reader->ReadSourceLocation(*F, Record, Idx, Seq);
   }
 
   /// Read a source range, advancing Idx.
-  SourceRange readSourceRange() {
-    return Reader->ReadSourceRange(*F, Record, Idx);
+  SourceRange readSourceRange(serialization::SourceLocationSeq *Seq = nullptr) {
+    return Reader->ReadSourceRange(*F, Record, Idx, Seq);
   }
 
   /// Read an arbitrary constant value, advancing Idx.
   // APValue readAPValue(); (inherited)
 
   /// Read an integral value, advancing Idx.
   // llvm::APInt readAPInt(); (inherited)
 

clang/include/clang/Serialization/ASTRecordWriter.h

public:
   /// Write an BTFTypeTagAttr object.
   void writeBTFTypeTagAttr(const BTFTypeTagAttr *A) { AddAttr(A); }
 
   /// Add a definition for the given function to the queue of statements
   /// to emit.
   void AddFunctionDefinition(const FunctionDecl *FD);
 
   /// Emit a source location.
-  void AddSourceLocation(SourceLocation Loc) {
-    return Writer->AddSourceLocation(Loc, *Record);
+  void AddSourceLocation(SourceLocation Loc,
+                         serialization::SourceLocationSeq *Seq = nullptr) {
+    return Writer->AddSourceLocation(Loc, *Record, Seq);
   }
   void writeSourceLocation(SourceLocation Loc) {
     AddSourceLocation(Loc);
   }
 
   /// Emit a source range.
-  void AddSourceRange(SourceRange Range) {
-    return Writer->AddSourceRange(Range, *Record);
+  void AddSourceRange(SourceRange Range,
+                      serialization::SourceLocationSeq *Seq = nullptr) {
+    return Writer->AddSourceRange(Range, *Record, Seq);
   }
 
   void writeBool(bool Value) {
     Record->push_back(Value);
   }
 
   void writeUInt32(uint32_t Value) {
     Record->push_back(Value);
public:
   void AddTypeRef(QualType T) {
     return Writer->AddTypeRef(T, *Record);
   }
   void writeQualType(QualType T) {
     AddTypeRef(T);
   }
 
   /// Emits a reference to a declarator info.
-  void AddTypeSourceInfo(TypeSourceInfo *TInfo);
+  void AddTypeSourceInfo(TypeSourceInfo *TInfo,
+                         serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Emits source location information for a type. Does not emit the type.
-  void AddTypeLoc(TypeLoc TL);
+  void AddTypeLoc(TypeLoc TL, serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Emits a template argument location info.
-  void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
-                                  const TemplateArgumentLocInfo &Arg);
+  void
+  AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
+                             const TemplateArgumentLocInfo &Arg,
+                             serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Emits a template argument location.
   void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg);
 
   /// Emits an AST template argument list info.
   void AddASTTemplateArgumentListInfo(
       const ASTTemplateArgumentListInfo *ASTTemplArgList);
 
   /// Emit a reference to a declaration.
   void AddDeclRef(const Decl *D) {
     return Writer->AddDeclRef(D, *Record);
   }
   void writeDeclRef(const Decl *D) {
     AddDeclRef(D);
   }
 
   /// Emit a declaration name.
   void AddDeclarationName(DeclarationName Name) {
     writeDeclarationName(Name);
   }
 
   void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
-                             DeclarationName Name);
+                             DeclarationName Name,
+                             serialization::SourceLocationSeq *Seq = nullptr);
   void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
 
-  void AddQualifierInfo(const QualifierInfo &Info);
+  void AddQualifierInfo(const QualifierInfo &Info,
+                        serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Emit a nested name specifier.
   void AddNestedNameSpecifier(NestedNameSpecifier *NNS) {
     writeNestedNameSpecifier(NNS);
   }
 
   /// Emit a nested name specifier with source-location information.
-  void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
+  void
+  AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
+                            serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Emit a template name.
   void AddTemplateName(TemplateName Name) {
     writeTemplateName(Name);
   }
 
   /// Emit a template argument.
   void AddTemplateArgument(const TemplateArgument &Arg) {
     writeTemplateArgument(Arg);
   }
 
   /// Emit a template parameter list.
-  void AddTemplateParameterList(const TemplateParameterList *TemplateParams);
+  void
+  AddTemplateParameterList(const TemplateParameterList *TemplateParams,
+                           serialization::SourceLocationSeq *Seq = nullptr);
 
   /// Emit a template argument list.
   void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs);
 
   /// Emit a UnresolvedSet structure.
   void AddUnresolvedSet(const ASTUnresolvedSet &Set);
 
   /// Emit a CXXCtorInitializer array.

clang/include/clang/Serialization/ASTWriter.h

 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConsumer.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Serialization/ASTDeserializationListener.h"
 #include "clang/Serialization/PCHContainerOperations.h"
+#include "clang/Serialization/SourceLocationEncoding.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
public:
   /// Emit a token.
   void AddToken(const Token &Tok, RecordDataImpl &Record);
 
   /// Emit a AlignPackInfo.
   void AddAlignPackInfo(const Sema::AlignPackInfo &Info,
                         RecordDataImpl &Record);
 
   /// Emit a source location.
-  void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record);
+  void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record,
+                         serialization::SourceLocationSeq *Seq = nullptr) {
+    Record.push_back(
+        Seq ? Seq->encode(Loc)
+            : serialization::SourceLocations::encodeRaw(Loc.getRawEncoding()));
+  }
 
   /// Emit a source range.
-  void AddSourceRange(SourceRange Range, RecordDataImpl &Record);
+  void AddSourceRange(SourceRange Range, RecordDataImpl &Record,
+                      serialization::SourceLocationSeq *Seq = nullptr) {
+    // FIXME: add fallback sequence?
+    AddSourceLocation(Range.getBegin(), Record, Seq);
+    AddSourceLocation(Range.getEnd(), Record, Seq);
+  }
 
   /// Emit a reference to an identifier.
   void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record);
 
   /// Get the unique number used to refer to the given selector.
   serialization::SelectorID getSelectorRef(Selector Sel);
 
   /// Get the unique number used to refer to the given identifier.

clang/include/clang/Serialization/SourceLocationEncoding.h

+//===--- SourceLocationEncoding.h - Small serialized locations --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+#include "clang/Basic/SourceLocation.h"
+
+#ifndef LLVM_CLANG_SERIALIZATION_SOURCELOCATIONENCODING_H
+#define LLVM_CLANG_SERIALIZATION_SOURCELOCATIONENCODING_H
+
+namespace clang {
+namespace serialization {
+
+/// Serialized encoding of SourceLocations without context.
+/// Optimized to have small unsigned values (=> small after VBR encoding).
+///
+// Macro locations have the top bit set, we rotate by one so it is the low bit.
+struct SourceLocations {
+  using UIntTy = SourceLocation::UIntTy;
+
+  static UIntTy encodeRaw(UIntTy Raw) {
+    return (Raw << 1) | (Raw >> (CHAR_BIT * sizeof(Raw) - 1));
+  }
+  static UIntTy decodeRaw(UIntTy Raw) {
+    return (Raw >> 1) | (Raw << (CHAR_BIT * sizeof(Raw) - 1));
+  }
+};
+
+/// Serialized encoding of a fixed-length sequence of SourceLocations.
+///
+/// Optimized to have small values in common cases: locations are null, or
+/// locations within the sequence are similar.
+///
+/// The sequence has a "state": initially zero, later the raw value of the last
+/// non-null location encoded.
+///
+/// Each subsequent location can be encoded:
+/// - directly: as SourceLocations::encodeRaw(value)          (if state is zero)
+/// - absolutely: as SourceLocations::encodeRaw(value) << 1          (low bit 0)
+/// - relatively: as zigzag(value - state)<<1 | 1                    (low bit 1)
+class SourceLocationSeq {
+  using UIntTy = SourceLocation::UIntTy;
+  UIntTy State = 0;
+  using EncodedTy = uint64_t;
+  static_assert(sizeof(EncodedTy) > sizeof(UIntTy), "Need one extra bit!");
+  constexpr static unsigned LocBits = sizeof(UIntTy) * CHAR_BIT;
+  constexpr static unsigned MaxDeltaEncodingBits = 18; // 3xVBR6
+
+public:
+  EncodedTy encodeRaw(UIntTy Raw) {
+    if (Raw == 0)
+      return 0;
+    UIntTy State = this->State;
+    this->State = Raw;
+
+    if (State == 0)
+      return SourceLocations::encodeRaw(Raw); // direct encoding
+
+    UIntTy Delta = Raw - State; // two's complement!
+    UIntTy Sign = (Delta & (1 << (LocBits - 1))) ? UIntTy(-1) : UIntTy(0);
+    UIntTy ZigZag = Sign ^ (Delta << 1);
+    if (ZigZag < (1 << (MaxDeltaEncodingBits - 1)))
+      return (ZigZag << 1) | 1; // relative
+    return EncodedTy(SourceLocations::encodeRaw(Raw)) << 1; // absolute
+  }
+  UIntTy decodeRaw(EncodedTy Encoded) {
+    if (State == 0)
+      return State = SourceLocations::decodeRaw(Encoded); // direct encoding
+    if (Encoded == 0)
+      return 0;
+    if ((Encoded & 1) == 0)
+      return State = SourceLocations::decodeRaw(Encoded >> 1); // absolute
+    UIntTy ZigZag = Encoded >> 1;
+    UIntTy Delta = (ZigZag >> 1) ^ -(ZigZag & 1); // two's complement!
+    return State = State + Delta;                 // relative
+  }
+
+  SourceLocation decode(EncodedTy Encoded) {
+    return SourceLocation::getFromRawEncoding(decodeRaw(Encoded));
+  }
+  EncodedTy encode(SourceLocation Loc) {
+    return encodeRaw(Loc.getRawEncoding());
+  }
+};
+
+class SourceLocationSeqRoot {
+  SourceLocationSeq *Seq;
+  SourceLocationSeq Local;
+
+public:
+  SourceLocationSeqRoot(SourceLocationSeq *Parent = nullptr)
+      : Seq(Parent ? Parent : &Local) {}
+
+  operator SourceLocationSeq *() const { return Seq; }
+};
+
+} // namespace serialization
+} // namespace clang
+#endif

clang/lib/Serialization/ASTReader.cpp

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
case SM_SLOC_BUFFER_ENTRY: {
     if (!Buffer)
       return true;
     SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
                            BaseOffset + Offset, IncludeLoc);
     break;
   }
 
   case SM_SLOC_EXPANSION_ENTRY: {
-    SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
-    SourceMgr.createExpansionLoc(SpellingLoc,
-                                     ReadSourceLocation(*F, Record[2]),
-                                     ReadSourceLocation(*F, Record[3]),
-                                     Record[5],
-                                     Record[4],
-                                     ID,
-                                     BaseOffset + Record[0]);
+    SourceLocationSeqRoot Seq;
+    SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1], Seq);
+    SourceLocation ExpansionBegin = ReadSourceLocation(*F, Record[2], Seq);
+    SourceLocation ExpansionEnd = ReadSourceLocation(*F, Record[3], Seq);
+    SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
+                                 Record[5], Record[4], ID,
     break;
   }
   }
 
   return false;
 }
 
 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
while (true) {
     case PP_MACRO_FUNCTION_LIKE: {
       // If we already have a macro, that means that we've hit the end
       // of the definition of the macro we were looking for. We're
       // done.
       if (Macro)
         return Macro;
 
       unsigned NextIndex = 1; // Skip identifier ID.
-      SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
+      SourceLocationSeqRoot Seq;
+      SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex, Seq);
       MacroInfo *MI = PP.AllocateMacroInfo(Loc);
-      MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
+      MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex, Seq));
       MI->setIsUsed(Record[NextIndex++]);
       MI->setUsedForHeaderGuard(Record[NextIndex++]);
       MacroTokens = MI->allocateTokens(Record[NextIndex++],
                                        PP.getPreprocessorAllocator());
       if (RecType == PP_MACRO_FUNCTION_LIKE) {
         // Decode function-like macro info.
         bool isC99VarArgs = Record[NextIndex++];
         bool isGNUVarArgs = Record[NextIndex++];
QualType ASTReader::readTypeRecord(unsigned Index) {
   serialization::AbstractTypeReader<ASTRecordReader> TypeReader(Record);
   return TypeReader.read(*maybeClass);
 }
 
 namespace clang {
 
 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
   ASTRecordReader &Reader;
+  SourceLocationSeq *Seq;
 
-  SourceLocation readSourceLocation() {
-    return Reader.readSourceLocation();
+  SourceLocation
+  readSourceLocation() {
+    //auto Raw = Reader.peekInt();
+    auto Loc = Reader.readSourceLocation(Seq);
+    //llvm::errs() << "read: " << llvm::to_hexString(Raw) << " => " << llvm::to_hexString(Loc.getRawEncoding()) << "\n";
+    return Loc;
   }
 
-  TypeSourceInfo *GetTypeSourceInfo() {
-    return Reader.readTypeSourceInfo();
+  SourceRange
+  readSourceRange() {
+    SourceLocation Begin = readSourceLocation();
+    SourceLocation End = readSourceLocation();
+    return SourceRange(Begin, End);
   }
 
+  TypeSourceInfo *GetTypeSourceInfo() { return Reader.readTypeSourceInfo(Seq); }
+
   NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
-    return Reader.readNestedNameSpecifierLoc();
+    return Reader.readNestedNameSpecifierLoc(Seq);
+  }
+
+  TemplateArgumentLocInfo
+  readTemplateArgumentLocInfo(TemplateArgument::ArgKind K) {
+    return Reader.readTemplateArgumentLocInfo(K, Seq);
   }
 
   Attr *ReadAttr() {
     return Reader.readAttr();
   }
 
 public:
-  TypeLocReader(ASTRecordReader &Reader) : Reader(Reader) {}
+  TypeLocReader(ASTRecordReader &Reader, SourceLocationSeq *Seq)
+      : Reader(Reader), Seq(Seq) {
+    //llvm::errs() << "locreader\n";
+  }
+  //~TypeLocReader() { llvm::errs() << "~locreader\n"; }
 
   // We want compile-time assurance that we've enumerated all of
   // these, so unfortunately we have to declare them first, then
   // define them out-of-line.
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
 #define TYPELOC(CLASS, PARENT) \
   void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
 #include "clang/AST/TypeLocNodes.def"
void TypeLocReader::VisitDependentSizedArrayTypeLoc(
                                             DependentSizedArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
 
 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
     DependentAddressSpaceTypeLoc TL) {
 
     TL.setAttrNameLoc(readSourceLocation());
-    TL.setAttrOperandParensRange(Reader.readSourceRange());
+    TL.setAttrOperandParensRange(readSourceRange());
     TL.setAttrExprOperand(Reader.readExpr());
 }
 
 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
                                         DependentSizedExtVectorTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitDependentVectorTypeLoc(
     DependentVectorTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) {
   TL.setAttrNameLoc(readSourceLocation());
-  TL.setAttrOperandParensRange(Reader.readSourceRange());
+  TL.setAttrOperandParensRange(readSourceRange());
   TL.setAttrRowOperand(Reader.readExpr());
   TL.setAttrColumnOperand(Reader.readExpr());
 }
 
 void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
     DependentSizedMatrixTypeLoc TL) {
   TL.setAttrNameLoc(readSourceLocation());
-  TL.setAttrOperandParensRange(Reader.readSourceRange());
+  TL.setAttrOperandParensRange(readSourceRange());
   TL.setAttrRowOperand(Reader.readExpr());
   TL.setAttrColumnOperand(Reader.readExpr());
 }
 
 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
   TL.setLocalRangeBegin(readSourceLocation());
   TL.setLParenLoc(readSourceLocation());
   TL.setRParenLoc(readSourceLocation());
-  TL.setExceptionSpecRange(Reader.readSourceRange());
+  TL.setExceptionSpecRange(readSourceRange());
   TL.setLocalRangeEnd(readSourceLocation());
   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
     TL.setParam(i, Reader.readDeclAs<ParmVarDecl>());
   }
 }
 
 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
   if (Reader.readBool()) {
     TL.setNestedNameSpecifierLoc(ReadNestedNameSpecifierLoc());
     TL.setTemplateKWLoc(readSourceLocation());
     TL.setConceptNameLoc(readSourceLocation());
     TL.setFoundDecl(Reader.readDeclAs<NamedDecl>());
     TL.setLAngleLoc(readSourceLocation());
     TL.setRAngleLoc(readSourceLocation());
     for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
-      TL.setArgLocInfo(i, Reader.readTemplateArgumentLocInfo(
-                              TL.getTypePtr()->getArg(i).getKind()));
+      TL.setArgLocInfo(
+          i, readTemplateArgumentLocInfo(TL.getTypePtr()->getArg(i).getKind()));
   }
   if (Reader.readBool())
     TL.setRParenLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
     DeducedTemplateSpecializationTypeLoc TL) {
   TL.setTemplateNameLoc(readSourceLocation());

 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
                                            TemplateSpecializationTypeLoc TL) {
   TL.setTemplateKeywordLoc(readSourceLocation());
   TL.setTemplateNameLoc(readSourceLocation());
   TL.setLAngleLoc(readSourceLocation());
   TL.setRAngleLoc(readSourceLocation());
   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
     TL.setArgLocInfo(
-        i,
-        Reader.readTemplateArgumentLocInfo(
-          TL.getTypePtr()->getArg(i).getKind()));
+        i, readTemplateArgumentLocInfo(TL.getTypePtr()->getArg(i).getKind()));
 }
 
 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
   TL.setLParenLoc(readSourceLocation());
   TL.setRParenLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
   TL.setElaboratedKeywordLoc(readSourceLocation());
   TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
   TL.setTemplateKeywordLoc(readSourceLocation());
   TL.setTemplateNameLoc(readSourceLocation());
   TL.setLAngleLoc(readSourceLocation());
   TL.setRAngleLoc(readSourceLocation());
   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
     TL.setArgLocInfo(
-        I,
-        Reader.readTemplateArgumentLocInfo(
-            TL.getTypePtr()->getArg(I).getKind()));
+        I, readTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind()));
 }
 
 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
   TL.setEllipsisLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());

 void TypeLocReader::VisitBitIntTypeLoc(clang::BitIntTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 void TypeLocReader::VisitDependentBitIntTypeLoc(
     clang::DependentBitIntTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
-
-void ASTRecordReader::readTypeLoc(TypeLoc TL) {
-  TypeLocReader TLR(*this);
-  for (; !TL.isNull(); TL = TL.getNextTypeLoc())
+void ASTRecordReader::readTypeLoc(TypeLoc TL,
+                                  serialization::SourceLocationSeq *OuterSeq) {
+  SourceLocationSeqRoot Seq(OuterSeq);
+  //llvm::errs() << "reading type loc nested=" << bool(Seq)<< "\n";
+  TypeLocReader TLR(*this, Seq);
+  for (; !TL.isNull(); TL = TL.getNextTypeLoc()) {
     TLR.Visit(TL);
+    //if (!TL.isNull())
+    //  llvm::errs() << "read " << TL.getType()->getTypeClassName() << "\n";
+  }
 }
 
-TypeSourceInfo *ASTRecordReader::readTypeSourceInfo() {
+TypeSourceInfo *ASTRecordReader::readTypeSourceInfo(SourceLocationSeq *Seq) {
   QualType InfoTy = readType();
   if (InfoTy.isNull())
     return nullptr;
 
   TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
-  readTypeLoc(TInfo->getTypeLoc());
+  readTypeLoc(TInfo->getTypeLoc(), Seq);
   return TInfo;
 }
 
 QualType ASTReader::GetType(TypeID ID) {
   assert(ContextObj && "reading type with no AST context");
   ASTContext &Context = *ContextObj;
 
   unsigned FastQuals = ID & Qualifiers::FastMask;
ContinuousRangeMap<uint32_t, int, 2>::iterator I
     = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
   assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
 
   unsigned GlobalIndex = LocalIndex + I->second;
   return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
 }
 
 TemplateArgumentLocInfo
-ASTRecordReader::readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
+ASTRecordReader::readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
+                                             SourceLocationSeq *Seq) {
   switch (Kind) {
   case TemplateArgument::Expression:
     return readExpr();
   case TemplateArgument::Type:
-    return readTypeSourceInfo();
+    return readTypeSourceInfo(Seq);
   case TemplateArgument::Template: {
     NestedNameSpecifierLoc QualifierLoc =
-      readNestedNameSpecifierLoc();
-    SourceLocation TemplateNameLoc = readSourceLocation();
+      readNestedNameSpecifierLoc(Seq);
+    SourceLocation TemplateNameLoc = readSourceLocation(Seq);
     return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
                                    TemplateNameLoc, SourceLocation());
   }
   case TemplateArgument::TemplateExpansion: {
-    NestedNameSpecifierLoc QualifierLoc = readNestedNameSpecifierLoc();
-    SourceLocation TemplateNameLoc = readSourceLocation();
-    SourceLocation EllipsisLoc = readSourceLocation();
+    NestedNameSpecifierLoc QualifierLoc = readNestedNameSpecifierLoc(Seq);
+    SourceLocation TemplateNameLoc = readSourceLocation(Seq);
+    SourceLocation EllipsisLoc = readSourceLocation(Seq);
     return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
                                    TemplateNameLoc, EllipsisLoc);
   }
   case TemplateArgument::Null:
   case TemplateArgument::Integral:
   case TemplateArgument::Declaration:
   case TemplateArgument::NullPtr:
   case TemplateArgument::Pack:
ContinuousRangeMap<uint32_t, int, 2>::iterator I
     = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
   assert(I != M.SelectorRemap.end()
          && "Invalid index into selector index remap");
 
   return LocalID + I->second;
 }
 
 DeclarationNameLoc
-ASTRecordReader::readDeclarationNameLoc(DeclarationName Name) {
+ASTRecordReader::readDeclarationNameLoc(DeclarationName Name,
+                                        SourceLocationSeq *Seq) {
   switch (Name.getNameKind()) {
   case DeclarationName::CXXConstructorName:
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
-    return DeclarationNameLoc::makeNamedTypeLoc(readTypeSourceInfo());
+    return DeclarationNameLoc::makeNamedTypeLoc(readTypeSourceInfo(Seq));
 
   case DeclarationName::CXXOperatorName:
-    return DeclarationNameLoc::makeCXXOperatorNameLoc(readSourceRange());
+    return DeclarationNameLoc::makeCXXOperatorNameLoc(readSourceRange(Seq));
 
   case DeclarationName::CXXLiteralOperatorName:
     return DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(
-        readSourceLocation());
+        readSourceLocation(Seq));
 
   case DeclarationName::Identifier:
   case DeclarationName::ObjCZeroArgSelector:
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector:
   case DeclarationName::CXXUsingDirective:
   case DeclarationName::CXXDeductionGuideName:
     break;
   }
   return DeclarationNameLoc();
 }
 
 DeclarationNameInfo ASTRecordReader::readDeclarationNameInfo() {
   DeclarationNameInfo NameInfo;
   NameInfo.setName(readDeclarationName());
   NameInfo.setLoc(readSourceLocation());
   NameInfo.setInfo(readDeclarationNameLoc(NameInfo.getName()));
   return NameInfo;
 }
 
-void ASTRecordReader::readQualifierInfo(QualifierInfo &Info) {
-  Info.QualifierLoc = readNestedNameSpecifierLoc();
+void ASTRecordReader::readQualifierInfo(QualifierInfo &Info,
+                                        SourceLocationSeq *Seq) {
+  Info.QualifierLoc = readNestedNameSpecifierLoc(Seq);
   unsigned NumTPLists = readInt();
   Info.NumTemplParamLists = NumTPLists;
   if (NumTPLists) {
     Info.TemplParamLists =
         new (getContext()) TemplateParameterList *[NumTPLists];
     for (unsigned i = 0; i != NumTPLists; ++i)
-      Info.TemplParamLists[i] = readTemplateParameterList();
+      Info.TemplParamLists[i] = readTemplateParameterList(Seq);
   }
 }
 
 TemplateParameterList *
-ASTRecordReader::readTemplateParameterList() {
-  SourceLocation TemplateLoc = readSourceLocation();
-  SourceLocation LAngleLoc = readSourceLocation();
-  SourceLocation RAngleLoc = readSourceLocation();
+ASTRecordReader::readTemplateParameterList(SourceLocationSeq *Seq) {
+  SourceLocation TemplateLoc = readSourceLocation(Seq);
+  SourceLocation LAngleLoc = readSourceLocation(Seq);
+  SourceLocation RAngleLoc = readSourceLocation(Seq);
 
   unsigned NumParams = readInt();
   SmallVector<NamedDecl *, 16> Params;
   Params.reserve(NumParams);
   while (NumParams--)
     Params.push_back(readDeclAs<NamedDecl>());
 
   bool HasRequiresClause = readBool();
for (unsigned i = 0; i != NumInitializers; ++i) {
 
     CtorInitializers[i] = BOMInit;
   }
 
   return CtorInitializers;
 }
 
 NestedNameSpecifierLoc
-ASTRecordReader::readNestedNameSpecifierLoc() {
+ASTRecordReader::readNestedNameSpecifierLoc(SourceLocationSeq *OuterSeq) {
+  SourceLocationSeqRoot Seq(OuterSeq);
   ASTContext &Context = getContext();
   unsigned N = readInt();
   NestedNameSpecifierLocBuilder Builder;
   for (unsigned I = 0; I != N; ++I) {
     auto Kind = readNestedNameSpecifierKind();
     switch (Kind) {
     case NestedNameSpecifier::Identifier: {
       IdentifierInfo *II = readIdentifier();
-      SourceRange Range = readSourceRange();
+      SourceRange Range = readSourceRange(Seq);
       Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
       break;
     }
 
     case NestedNameSpecifier::Namespace: {
       NamespaceDecl *NS = readDeclAs<NamespaceDecl>();
-      SourceRange Range = readSourceRange();
+      SourceRange Range = readSourceRange(Seq);
       Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
       break;
     }
 
     case NestedNameSpecifier::NamespaceAlias: {
       NamespaceAliasDecl *Alias = readDeclAs<NamespaceAliasDecl>();
-      SourceRange Range = readSourceRange();
+      SourceRange Range = readSourceRange(Seq);
       Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
       break;
     }
 
     case NestedNameSpecifier::TypeSpec:
     case NestedNameSpecifier::TypeSpecWithTemplate: {
       bool Template = readBool();
-      TypeSourceInfo *T = readTypeSourceInfo();
+      TypeSourceInfo *T = readTypeSourceInfo(Seq);
       if (!T)
         return NestedNameSpecifierLoc();
-      SourceLocation ColonColonLoc = readSourceLocation();
+      SourceLocation ColonColonLoc = readSourceLocation(Seq);
 
       // FIXME: 'template' keyword location not saved anywhere, so we fake it.
       Builder.Extend(Context,
                      Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
                      T->getTypeLoc(), ColonColonLoc);
       break;
     }
 
     case NestedNameSpecifier::Global: {
-      SourceLocation ColonColonLoc = readSourceLocation();
+      SourceLocation ColonColonLoc = readSourceLocation(Seq);
       Builder.MakeGlobal(Context, ColonColonLoc);
       break;
     }
 
     case NestedNameSpecifier::Super: {
       CXXRecordDecl *RD = readDeclAs<CXXRecordDecl>();
-      SourceRange Range = readSourceRange();
+      SourceRange Range = readSourceRange(Seq);
       Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
       break;
     }
     }
   }
 
   return Builder.getWithLocInContext(Context);
 }
 
-SourceRange
-ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
-                           unsigned &Idx) {
-  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
-  SourceLocation end = ReadSourceLocation(F, Record, Idx);
-  return SourceRange(beg, end);
-}
-
 /// Read a floating-point value
 llvm::APFloat ASTRecordReader::readAPFloat(const llvm::fltSemantics &Sem) {
   return llvm::APFloat(Sem, readAPInt());
 }
 
 // Read a string
 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
   unsigned Len = Record[Idx++];

clang/lib/Serialization/ASTReaderDecl.cpp

uint64_t ReadLocalOffset() {
       return LocalOffset ? Loc.Offset - LocalOffset : 0;
     }
 
     uint64_t ReadGlobalOffset() {
       uint64_t Local = ReadLocalOffset();
       return Local ? Record.getGlobalBitOffset(Local) : 0;
     }
 
-    SourceLocation readSourceLocation() {
-      return Record.readSourceLocation();
+    SourceLocation readSourceLocation(SourceLocationSeq *Seq = nullptr) {
+      return Record.readSourceLocation(Seq);
     }
 
-    SourceRange readSourceRange() {
-      return Record.readSourceRange();
+    SourceRange readSourceRange(SourceLocationSeq *Seq = nullptr) {
+      return Record.readSourceRange(Seq);
     }
 
-    TypeSourceInfo *readTypeSourceInfo() {
-      return Record.readTypeSourceInfo();
+    TypeSourceInfo *readTypeSourceInfo(SourceLocationSeq *Seq = nullptr) {
+      return Record.readTypeSourceInfo(Seq);
     }
 
     serialization::DeclID readDeclID() {
       return Record.readDeclID();
     }
 
     std::string readString() {
       return Record.readString();
public:
     }
 
     void VisitVarTemplatePartialSpecializationDecl(
         VarTemplatePartialSpecializationDecl *D);
     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
     void VisitValueDecl(ValueDecl *VD);
     void VisitEnumConstantDecl(EnumConstantDecl *ECD);
     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
-    void VisitDeclaratorDecl(DeclaratorDecl *DD);
+    void VisitDeclaratorDecl(DeclaratorDecl *DD,
+                             SourceLocationSeq *Seq = nullptr);
     void VisitFunctionDecl(FunctionDecl *FD);
     void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *GD);
     void VisitCXXMethodDecl(CXXMethodDecl *D);
     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
     void VisitCXXConversionDecl(CXXConversionDecl *D);
     void VisitFieldDecl(FieldDecl *FD);
     void VisitMSPropertyDecl(MSPropertyDecl *FD);

 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
   VisitValueDecl(ECD);
   if (Record.readInt())
     ECD->setInitExpr(Record.readExpr());
   ECD->setInitVal(Record.readAPSInt());
   mergeMergeable(ECD);
 }
 
-void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
+void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD,
+                                        SourceLocationSeq *Seq) {
   VisitValueDecl(DD);
-  DD->setInnerLocStart(readSourceLocation());
+  DD->setInnerLocStart(readSourceLocation(Seq));
   if (Record.readInt()) { // hasExtInfo
     auto *Info = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
-    Record.readQualifierInfo(*Info);
+    Record.readQualifierInfo(*Info, Seq);
     Info->TrailingRequiresClause = Record.readExpr();
     DD->DeclInfo = Info;
   }
   QualType TSIType = Record.readType();
   DD->setTypeSourceInfo(
       TSIType.isNull() ? nullptr
                        : Reader.getContext().CreateTypeSourceInfo(TSIType));
 }
 
 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
+  SourceLocationSeqRoot Seq;
   RedeclarableResult Redecl = VisitRedeclarable(FD);
-  VisitDeclaratorDecl(FD);
+  VisitDeclaratorDecl(FD, Seq);
 
   // Attach a type to this function. Use the real type if possible, but fall
   // back to the type as written if it involves a deduced return type.
   if (FD->getTypeSourceInfo() &&
       FD->getTypeSourceInfo()->getType()->castAs<FunctionType>()
                              ->getReturnType()->getContainedAutoType()) {
     // We'll set up the real type in Visit, once we've finished loading the
     // function.
     FD->setType(FD->getTypeSourceInfo()->getType());
     Reader.PendingFunctionTypes.push_back({FD, DeferredTypeID});
   } else {
     FD->setType(Reader.GetType(DeferredTypeID));
   }
   DeferredTypeID = 0;
 
-  FD->DNLoc = Record.readDeclarationNameLoc(FD->getDeclName());
+  FD->DNLoc = Record.readDeclarationNameLoc(FD->getDeclName(), Seq);
   FD->IdentifierNamespace = Record.readInt();
 
   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
   // after everything else is read.
 
   FD->setStorageClass(static_cast<StorageClass>(Record.readInt()));
   FD->setInlineSpecified(Record.readInt());
   FD->setImplicitlyInline(Record.readInt());
void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   FD->setHasImplicitReturnZero(Record.readInt());
   FD->setConstexprKind(static_cast<ConstexprSpecKind>(Record.readInt()));
   FD->setUsesSEHTry(Record.readInt());
   FD->setHasSkippedBody(Record.readInt());
   FD->setIsMultiVersion(Record.readInt());
   FD->setLateTemplateParsed(Record.readInt());
 
   FD->setCachedLinkage(static_cast<Linkage>(Record.readInt()));
-  FD->EndRangeLoc = readSourceLocation();
+  FD->EndRangeLoc = readSourceLocation(Seq);
 
   FD->ODRHash = Record.readInt();
   FD->setHasODRHash(true);
 
   if (FD->isDefaulted()) {
     if (unsigned NumLookups = Record.readInt()) {
       SmallVector<DeclAccessPair, 8> Lookups;
       for (unsigned I = 0; I != NumLookups; ++I) {
case FunctionDecl::TK_NonTemplate:
     break;
   case FunctionDecl::TK_FunctionTemplate:
     // Merged when we merge the template.
     FD->setDescribedFunctionTemplate(readDeclAs<FunctionTemplateDecl>());
     break;
   case FunctionDecl::TK_MemberSpecialization: {
     auto *InstFD = readDeclAs<FunctionDecl>();
     auto TSK = (TemplateSpecializationKind)Record.readInt();
-    SourceLocation POI = readSourceLocation();
+    SourceLocation POI = readSourceLocation(Seq);
     FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
     FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
     mergeRedeclarable(FD, Redecl);
     break;
   }
   case FunctionDecl::TK_FunctionTemplateSpecialization: {
     auto *Template = readDeclAs<FunctionTemplateDecl>();
     auto TSK = (TemplateSpecializationKind)Record.readInt();
 
     // Template arguments.
     SmallVector<TemplateArgument, 8> TemplArgs;
     Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
 
     // Template args as written.
     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
     SourceLocation LAngleLoc, RAngleLoc;
     bool HasTemplateArgumentsAsWritten = Record.readInt();
     if (HasTemplateArgumentsAsWritten) {
       unsigned NumTemplateArgLocs = Record.readInt();
       TemplArgLocs.reserve(NumTemplateArgLocs);
       for (unsigned i = 0; i != NumTemplateArgLocs; ++i)
-        TemplArgLocs.push_back(Record.readTemplateArgumentLoc());
+        TemplArgLocs.push_back(Record.readTemplateArgumentLoc()); // FIXME: seq
 
-      LAngleLoc = readSourceLocation();
-      RAngleLoc = readSourceLocation();
+      LAngleLoc = readSourceLocation(Seq);
+      RAngleLoc = readSourceLocation(Seq);
     }
 
-    SourceLocation POI = readSourceLocation();
+    SourceLocation POI = readSourceLocation(Seq);
 
     ASTContext &C = Reader.getContext();
     TemplateArgumentList *TemplArgList
       = TemplateArgumentList::CreateCopy(C, TemplArgs);
     TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
     for (unsigned i = 0, e = TemplArgLocs.size(); i != e; ++i)
       TemplArgsInfo.addArgument(TemplArgLocs[i]);
 
     MemberSpecializationInfo *MSInfo = nullptr;
     if (Record.readInt()) {
       auto *FD = readDeclAs<FunctionDecl>();
       auto TSK = (TemplateSpecializationKind)Record.readInt();
-      SourceLocation POI = readSourceLocation();
+      SourceLocation POI = readSourceLocation(Seq);
 
       MSInfo = new (C) MemberSpecializationInfo(FD, TSK);
       MSInfo->setPointOfInstantiation(POI);
     }
 
     FunctionTemplateSpecializationInfo *FTInfo =
         FunctionTemplateSpecializationInfo::Create(
             C, FD, Template, TSK, TemplArgList,
case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     unsigned NumTemplates = Record.readInt();
     while (NumTemplates--)
       TemplDecls.addDecl(readDeclAs<NamedDecl>());
 
     // Templates args.
     TemplateArgumentListInfo TemplArgs;
     unsigned NumArgs = Record.readInt();
     while (NumArgs--)
-      TemplArgs.addArgument(Record.readTemplateArgumentLoc());
-    TemplArgs.setLAngleLoc(readSourceLocation());
-    TemplArgs.setRAngleLoc(readSourceLocation());
+      TemplArgs.addArgument(Record.readTemplateArgumentLoc()); // FIXME: seq
+    TemplArgs.setLAngleLoc(readSourceLocation(Seq));
+    TemplArgs.setRAngleLoc(readSourceLocation(Seq));
 
     FD->setDependentTemplateSpecialization(Reader.getContext(),
                                            TemplDecls, TemplArgs);
     // These are not merged; we don't need to merge redeclarations of dependent
     // template friends.
     break;
   }
   }

clang/lib/Serialization/ASTReaderStmt.cpp

 using namespace serialization;
 
 namespace clang {
 
   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
     ASTRecordReader &Record;
     llvm::BitstreamCursor &DeclsCursor;
 
-    SourceLocation readSourceLocation() {
-      return Record.readSourceLocation();
+    SourceLocation readSourceLocation(SourceLocationSeq *Seq = nullptr) {
+      return Record.readSourceLocation(Seq);
     }
 
     SourceRange readSourceRange() {
       return Record.readSourceRange();
     }
 
     std::string readString() {
       return Record.readString();

 
 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
   VisitBinaryOperator(E);
   E->setComputationLHSType(Record.readType());
   E->setComputationResultType(Record.readType());
 }
 
 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
+  serialization::SourceLocationSeq Seq;
   VisitExpr(E);
   E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
   E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
   E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
-  E->QuestionLoc = readSourceLocation();
-  E->ColonLoc = readSourceLocation();
+  E->QuestionLoc = readSourceLocation(&Seq);
+  E->ColonLoc = readSourceLocation(&Seq);
 }
 
 void
 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
+  serialization::SourceLocationSeq Seq;
   VisitExpr(E);
   E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
   E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
   E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
   E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
   E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
-  E->QuestionLoc = readSourceLocation();
-  E->ColonLoc = readSourceLocation();
+  E->QuestionLoc = readSourceLocation(&Seq);
+  E->ColonLoc = readSourceLocation(&Seq);
 }
 
 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
   VisitCastExpr(E);
   E->setIsPartOfExplicitCast(Record.readInt());
 }
 
 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   VisitCastExpr(E);
   E->setTypeInfoAsWritten(readTypeSourceInfo());
 }
 
 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
+  serialization::SourceLocationSeq Seq;
   VisitExplicitCastExpr(E);
-  E->setLParenLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
+  E->setLParenLoc(readSourceLocation(&Seq));
+  E->setRParenLoc(readSourceLocation(&Seq));
 }
 
 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   E->setLParenLoc(readSourceLocation());
   E->setTypeSourceInfo(readTypeSourceInfo());
   E->setInitializer(Record.readSubExpr());
   E->setFileScope(Record.readInt());

clang/lib/Serialization/ASTWriter.cpp

 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA1.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
uint64_t write(QualType T) {
     atw.write(typePtr);
     return BasicWriter.Emit(getTypeCodeForTypeClass(typePtr->getTypeClass()),
                             /*abbrev*/ 0);
   }
 };
 
 class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
   ASTRecordWriter &Record;
+  SourceLocationSeq *Seq;
+
+  void AddSourceLocation(SourceLocation Loc) {
+    //llvm::errs() << "wrote: " << llvm::to_hexString(Loc.getRawEncoding());
+    Record.AddSourceLocation(Loc, Seq);
+    //llvm::errs() << " => " << llvm::to_hexString(Record.getRecordData().back()) << "\n";
+  }
+  void AddSourceRange(SourceRange Range) {
+    AddSourceLocation(Range.getBegin());
+    AddSourceLocation(Range.getEnd());
+  }
+  void AddTypeSourceInfo(TypeSourceInfo *TInfo) {
+    Record.AddTypeSourceInfo(TInfo, Seq);
+  }
+  void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
+    Record.AddNestedNameSpecifierLoc(NNS, Seq);
+  }
+  void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
+                                  const TemplateArgumentLocInfo &Arg) {
+    Record.AddTemplateArgumentLocInfo(Kind, Arg, Seq);
+  }
 
 public:
-  TypeLocWriter(ASTRecordWriter &Record) : Record(Record) {}
+  TypeLocWriter(ASTRecordWriter &Record, SourceLocationSeq *Seq)
+      : Record(Record), Seq(Seq) {
+    //llvm::errs() << "locwriter\n";
+  }
+  ~TypeLocWriter() {
+    //llvm::errs() << "~locwriter\n";
+  }
 
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
 #define TYPELOC(CLASS, PARENT) \
     void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
 #include "clang/AST/TypeLocNodes.def"
 
   void VisitArrayTypeLoc(ArrayTypeLoc TyLoc);
   void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc);
 };
 
 } // namespace
 
 void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
   // nothing to do
 }
 
 void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
-  Record.AddSourceLocation(TL.getBuiltinLoc());
+  AddSourceLocation(TL.getBuiltinLoc());
   if (TL.needsExtraLocalData()) {
     Record.push_back(TL.getWrittenTypeSpec());
     Record.push_back(static_cast<uint64_t>(TL.getWrittenSignSpec()));
     Record.push_back(static_cast<uint64_t>(TL.getWrittenWidthSpec()));
     Record.push_back(TL.hasModeAttr());
   }
 }
 
 void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
-  Record.AddSourceLocation(TL.getStarLoc());
+  AddSourceLocation(TL.getStarLoc());
 }
 
 void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
   // nothing to do
 }
 
 void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
   // nothing to do
 }
 
 void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
-  Record.AddSourceLocation(TL.getCaretLoc());
+  AddSourceLocation(TL.getCaretLoc());
 }
 
 void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
-  Record.AddSourceLocation(TL.getAmpLoc());
+  AddSourceLocation(TL.getAmpLoc());
 }
 
 void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
-  Record.AddSourceLocation(TL.getAmpAmpLoc());
+  AddSourceLocation(TL.getAmpAmpLoc());
 }
 
 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
-  Record.AddSourceLocation(TL.getStarLoc());
-  Record.AddTypeSourceInfo(TL.getClassTInfo());
+  AddSourceLocation(TL.getStarLoc());
+  AddTypeSourceInfo(TL.getClassTInfo());
 }
 
 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
-  Record.AddSourceLocation(TL.getLBracketLoc());
-  Record.AddSourceLocation(TL.getRBracketLoc());
+  AddSourceLocation(TL.getLBracketLoc());
+  AddSourceLocation(TL.getRBracketLoc());
   Record.push_back(TL.getSizeExpr() ? 1 : 0);
   if (TL.getSizeExpr())
     Record.AddStmt(TL.getSizeExpr());
 }
 
 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
 
 void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
 
 void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
 
 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
                                             DependentSizedArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
 
 void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
     DependentAddressSpaceTypeLoc TL) {
-  Record.AddSourceLocation(TL.getAttrNameLoc());
+  AddSourceLocation(TL.getAttrNameLoc());
   SourceRange range = TL.getAttrOperandParensRange();
-  Record.AddSourceLocation(range.getBegin());
-  Record.AddSourceLocation(range.getEnd());
+  AddSourceLocation(range.getBegin());
+  AddSourceLocation(range.getEnd());
   Record.AddStmt(TL.getAttrExprOperand());
 }
 
 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
                                         DependentSizedExtVectorTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitDependentVectorTypeLoc(
     DependentVectorTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) {
-  Record.AddSourceLocation(TL.getAttrNameLoc());
+  AddSourceLocation(TL.getAttrNameLoc());
   SourceRange range = TL.getAttrOperandParensRange();
-  Record.AddSourceLocation(range.getBegin());
-  Record.AddSourceLocation(range.getEnd());
+  AddSourceLocation(range.getBegin());
+  AddSourceLocation(range.getEnd());
   Record.AddStmt(TL.getAttrRowOperand());
   Record.AddStmt(TL.getAttrColumnOperand());
 }
 
 void TypeLocWriter::VisitDependentSizedMatrixTypeLoc(
     DependentSizedMatrixTypeLoc TL) {
-  Record.AddSourceLocation(TL.getAttrNameLoc());
+  AddSourceLocation(TL.getAttrNameLoc());
   SourceRange range = TL.getAttrOperandParensRange();
-  Record.AddSourceLocation(range.getBegin());
-  Record.AddSourceLocation(range.getEnd());
+  AddSourceLocation(range.getBegin());
+  AddSourceLocation(range.getEnd());
   Record.AddStmt(TL.getAttrRowOperand());
   Record.AddStmt(TL.getAttrColumnOperand());
 }
 
 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
-  Record.AddSourceLocation(TL.getLocalRangeBegin());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
-  Record.AddSourceRange(TL.getExceptionSpecRange());
-  Record.AddSourceLocation(TL.getLocalRangeEnd());
+  AddSourceLocation(TL.getLocalRangeBegin());
+  AddSourceLocation(TL.getLParenLoc());
+  AddSourceLocation(TL.getRParenLoc());
+  AddSourceRange(TL.getExceptionSpecRange());
+  AddSourceLocation(TL.getLocalRangeEnd());
   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
     Record.AddDeclRef(TL.getParam(i));
 }
 
 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }
 
 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }
 
 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitUsingTypeLoc(UsingTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
   if (TL.getNumProtocols()) {
-    Record.AddSourceLocation(TL.getProtocolLAngleLoc());
-    Record.AddSourceLocation(TL.getProtocolRAngleLoc());
+    AddSourceLocation(TL.getProtocolLAngleLoc());
+    AddSourceLocation(TL.getProtocolRAngleLoc());
   }
   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
-    Record.AddSourceLocation(TL.getProtocolLoc(i));
+    AddSourceLocation(TL.getProtocolLoc(i));
 }
 
 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
-  Record.AddSourceLocation(TL.getTypeofLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  AddSourceLocation(TL.getTypeofLoc());
+  AddSourceLocation(TL.getLParenLoc());
+  AddSourceLocation(TL.getRParenLoc());
 }
 
 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
-  Record.AddSourceLocation(TL.getTypeofLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
-  Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
+  AddSourceLocation(TL.getTypeofLoc());
+  AddSourceLocation(TL.getLParenLoc());
+  AddSourceLocation(TL.getRParenLoc());
+  AddTypeSourceInfo(TL.getUnderlyingTInfo());
 }
 
 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
-  Record.AddSourceLocation(TL.getDecltypeLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  AddSourceLocation(TL.getDecltypeLoc());
+  AddSourceLocation(TL.getRParenLoc());
 }
 
 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
-  Record.AddSourceLocation(TL.getKWLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
-  Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
+  AddSourceLocation(TL.getKWLoc());
+  AddSourceLocation(TL.getLParenLoc());
+  AddSourceLocation(TL.getRParenLoc());
+  AddTypeSourceInfo(TL.getUnderlyingTInfo());
 }
 
 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
   Record.push_back(TL.isConstrained());
   if (TL.isConstrained()) {
-    Record.AddNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc());
-    Record.AddSourceLocation(TL.getTemplateKWLoc());
-    Record.AddSourceLocation(TL.getConceptNameLoc());
+    AddNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc());
+    AddSourceLocation(TL.getTemplateKWLoc());
+    AddSourceLocation(TL.getConceptNameLoc());
     Record.AddDeclRef(TL.getFoundDecl());
-    Record.AddSourceLocation(TL.getLAngleLoc());
-    Record.AddSourceLocation(TL.getRAngleLoc());
+    AddSourceLocation(TL.getLAngleLoc());
+    AddSourceLocation(TL.getRAngleLoc());
     for (unsigned I = 0; I < TL.getNumArgs(); ++I)
-      Record.AddTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(),
+      AddTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(),
                                         TL.getArgLocInfo(I));
   }
   Record.push_back(TL.isDecltypeAuto());
   if (TL.isDecltypeAuto())
-    Record.AddSourceLocation(TL.getRParenLoc());
+    AddSourceLocation(TL.getRParenLoc());
 }
 
 void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
     DeducedTemplateSpecializationTypeLoc TL) {
-  Record.AddSourceLocation(TL.getTemplateNameLoc());
+  AddSourceLocation(TL.getTemplateNameLoc());
 }
 
 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
   Record.AddAttr(TL.getAttr());
 }
 
 void TypeLocWriter::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
   // Nothing to do.
 }
 
 void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
                                             SubstTemplateTypeParmTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
                                           SubstTemplateTypeParmPackTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
                                            TemplateSpecializationTypeLoc TL) {
-  Record.AddSourceLocation(TL.getTemplateKeywordLoc());
-  Record.AddSourceLocation(TL.getTemplateNameLoc());
-  Record.AddSourceLocation(TL.getLAngleLoc());
-  Record.AddSourceLocation(TL.getRAngleLoc());
+  AddSourceLocation(TL.getTemplateKeywordLoc());
+  AddSourceLocation(TL.getTemplateNameLoc());
+  AddSourceLocation(TL.getLAngleLoc());
+  AddSourceLocation(TL.getRAngleLoc());
   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
-    Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
+    AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
                                       TL.getArgLoc(i).getLocInfo());
 }
 
 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  AddSourceLocation(TL.getLParenLoc());
+  AddSourceLocation(TL.getRParenLoc());
 }
 
 void TypeLocWriter::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
-  Record.AddSourceLocation(TL.getExpansionLoc());
+  AddSourceLocation(TL.getExpansionLoc());
 }
 
 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
-  Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
-  Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
+  AddSourceLocation(TL.getElaboratedKeywordLoc());
+  AddNestedNameSpecifierLoc(TL.getQualifierLoc());
 }
 
 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
-  Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
-  Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getElaboratedKeywordLoc());
+  AddNestedNameSpecifierLoc(TL.getQualifierLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
        DependentTemplateSpecializationTypeLoc TL) {
-  Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
-  Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
-  Record.AddSourceLocation(TL.getTemplateKeywordLoc());
-  Record.AddSourceLocation(TL.getTemplateNameLoc());
-  Record.AddSourceLocation(TL.getLAngleLoc());
-  Record.AddSourceLocation(TL.getRAngleLoc());
+  AddSourceLocation(TL.getElaboratedKeywordLoc());
+  AddNestedNameSpecifierLoc(TL.getQualifierLoc());
+  AddSourceLocation(TL.getTemplateKeywordLoc());
+  AddSourceLocation(TL.getTemplateNameLoc());
+  AddSourceLocation(TL.getLAngleLoc());
+  AddSourceLocation(TL.getRAngleLoc());
   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
-    Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
-                                      TL.getArgLoc(I).getLocInfo());
+    AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
 }
 
 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
-  Record.AddSourceLocation(TL.getEllipsisLoc());
+  AddSourceLocation(TL.getEllipsisLoc());
 }
 
 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
   Record.push_back(TL.hasBaseTypeAsWritten());
-  Record.AddSourceLocation(TL.getTypeArgsLAngleLoc());
-  Record.AddSourceLocation(TL.getTypeArgsRAngleLoc());
+  AddSourceLocation(TL.getTypeArgsLAngleLoc());
+  AddSourceLocation(TL.getTypeArgsRAngleLoc());
   for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
-    Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i));
-  Record.AddSourceLocation(TL.getProtocolLAngleLoc());
-  Record.AddSourceLocation(TL.getProtocolRAngleLoc());
+    AddTypeSourceInfo(TL.getTypeArgTInfo(i));
+  AddSourceLocation(TL.getProtocolLAngleLoc());
+  AddSourceLocation(TL.getProtocolRAngleLoc());
   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
-    Record.AddSourceLocation(TL.getProtocolLoc(i));
+    AddSourceLocation(TL.getProtocolLoc(i));
 }
 
 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
-  Record.AddSourceLocation(TL.getStarLoc());
+  AddSourceLocation(TL.getStarLoc());
 }
 
 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
-  Record.AddSourceLocation(TL.getKWLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  AddSourceLocation(TL.getKWLoc());
+  AddSourceLocation(TL.getLParenLoc());
+  AddSourceLocation(TL.getRParenLoc());
 }
 
 void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) {
-  Record.AddSourceLocation(TL.getKWLoc());
+  AddSourceLocation(TL.getKWLoc());
 }
 
 void TypeLocWriter::VisitBitIntTypeLoc(clang::BitIntTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 void TypeLocWriter::VisitDependentBitIntTypeLoc(
     clang::DependentBitIntTypeLoc TL) {
-  Record.AddSourceLocation(TL.getNameLoc());
+  AddSourceLocation(TL.getNameLoc());
 }
 
 void ASTWriter::WriteTypeAbbrevs() {
   using namespace llvm;
 
   std::shared_ptr<BitCodeAbbrev> Abv;
 
   // Abbreviation for TYPE_EXT_QUAL
if (SLoc->isFile()) {
           Buffer = llvm::MemoryBufferRef("<<<INVALID BUFFER>>>", "");
         StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
         emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
                  SLocBufferBlobAbbrv);
       }
     } else {
       // The source location entry is a macro expansion.
       const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
-      AddSourceLocation(Expansion.getSpellingLoc(), Record);
-      AddSourceLocation(Expansion.getExpansionLocStart(), Record);
+      SourceLocationSeqRoot Seq;
+      AddSourceLocation(Expansion.getSpellingLoc(), Record, Seq);
+      AddSourceLocation(Expansion.getExpansionLocStart(), Record, Seq);
       AddSourceLocation(Expansion.isMacroArgExpansion()
                             ? SourceLocation()
                             : Expansion.getExpansionLocEnd(),
-                        Record);
+                        Record, Seq);
       Record.push_back(Expansion.isExpansionTokenRange());
 
       // Compute the token length for this macro expansion.
       SourceLocation::UIntTy NextOffset = SourceMgr.getNextLocalOffset();
       if (I + 1 != N)
         NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
       Record.push_back(NextOffset - SLoc->getOffset() - 1);
       Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
     if (Index >= MacroOffsets.size())
       MacroOffsets.resize(Index + 1);
 
     uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
     assert((Offset >> 32) == 0 && "Macro offset too large");
     MacroOffsets[Index] = Offset;
 
     AddIdentifierRef(Name, Record);
-    AddSourceLocation(MI->getDefinitionLoc(), Record);
-    AddSourceLocation(MI->getDefinitionEndLoc(), Record);
+    SourceLocationSeqRoot Seq;
+    AddSourceLocation(MI->getDefinitionLoc(), Record, Seq);
+    AddSourceLocation(MI->getDefinitionEndLoc(), Record, Seq);
     Record.push_back(MI->isUsed());
     Record.push_back(MI->isUsedForHeaderGuard());
     Record.push_back(MI->getNumTokens());
     unsigned Code;
     if (MI->isObjectLike()) {
       Code = PP_MACRO_OBJECT_LIKE;
     } else {
       Code = PP_MACRO_FUNCTION_LIKE;

 }
 
 void ASTWriter::AddAlignPackInfo(const Sema::AlignPackInfo &Info,
                                  RecordDataImpl &Record) {
   uint32_t Raw = Sema::AlignPackInfo::getRawEncoding(Info);
   Record.push_back(Raw);
 }
 
-void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
-  SourceLocation::UIntTy Raw = Loc.getRawEncoding();
-  Record.push_back((Raw << 1) | (Raw >> (8 * sizeof(Raw) - 1)));
-}
-
-void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) {
-  AddSourceLocation(Range.getBegin(), Record);
-  AddSourceLocation(Range.getEnd(), Record);
-}
-
 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) {
   AddAPInt(Value.bitcastToAPInt());
 }
 
 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) {
   Record.push_back(getIdentifierRef(II));
 }
 
SelectorID ASTWriter::getSelectorRef(Selector Sel) {
   return SID;
 }
 
 void ASTRecordWriter::AddCXXTemporary(const CXXTemporary *Temp) {
   AddDeclRef(Temp->getDestructor());
 }
 
 void ASTRecordWriter::AddTemplateArgumentLocInfo(
-    TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg) {
+    TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg,
+    SourceLocationSeq *Seq) {
   switch (Kind) {
   case TemplateArgument::Expression:
     AddStmt(Arg.getAsExpr());
     break;
   case TemplateArgument::Type:
-    AddTypeSourceInfo(Arg.getAsTypeSourceInfo());
+    AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Seq);
     break;
   case TemplateArgument::Template:
-    AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc());
-    AddSourceLocation(Arg.getTemplateNameLoc());
+    AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Seq);
+    AddSourceLocation(Arg.getTemplateNameLoc(), Seq);
     break;
   case TemplateArgument::TemplateExpansion:
-    AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc());
-    AddSourceLocation(Arg.getTemplateNameLoc());
-    AddSourceLocation(Arg.getTemplateEllipsisLoc());
+    AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Seq);
+    AddSourceLocation(Arg.getTemplateNameLoc(), Seq);
+    AddSourceLocation(Arg.getTemplateEllipsisLoc(), Seq);
     break;
   case TemplateArgument::Null:
   case TemplateArgument::Integral:
   case TemplateArgument::Declaration:
   case TemplateArgument::NullPtr:
   case TemplateArgument::Pack:
     // FIXME: Is this right?
     break;
   }
 }
 
 void ASTRecordWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) {
   AddTemplateArgument(Arg.getArgument());
 
   if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
     bool InfoHasSameExpr
       = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
     Record->push_back(InfoHasSameExpr);
     if (InfoHasSameExpr)
       return; // Avoid storing the same expr twice.
   }
   AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo());
 }
 
-void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo) {
+void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo,
+                                        serialization::SourceLocationSeq *Seq) {
   if (!TInfo) {
     AddTypeRef(QualType());
     return;
   }
 
   AddTypeRef(TInfo->getType());
-  AddTypeLoc(TInfo->getTypeLoc());
+  AddTypeLoc(TInfo->getTypeLoc(), Seq);
 }
 
-void ASTRecordWriter::AddTypeLoc(TypeLoc TL) {
-  TypeLocWriter TLW(*this);
+void ASTRecordWriter::AddTypeLoc(TypeLoc TL,
+                                 serialization::SourceLocationSeq *OuterSeq) {
+  SourceLocationSeqRoot Seq(OuterSeq);
+  //
+  //llvm::errs() << "writing type loc nested=" << bool(Seq)<< "\n";
+  //  if (!TL.isNull())
+  //    llvm::errs() << "writing " << TL.getType()->getTypeClassName() << "\n";
+  TypeLocWriter TLW(*this, Seq);
   for (; !TL.isNull(); TL = TL.getNextTypeLoc())
     TLW.Visit(TL);
 }
 
 void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) {
   Record.push_back(GetOrCreateTypeID(T));
 }
 
if (It == AnonymousDeclarationNumbers.end()) {
     assert(It != AnonymousDeclarationNumbers.end() &&
            "declaration not found within its lexical context");
   }
 
   return It->second;
 }
 
 void ASTRecordWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
-                                            DeclarationName Name) {
+                                            DeclarationName Name,
+                                            SourceLocationSeq *Seq) {
   switch (Name.getNameKind()) {
   case DeclarationName::CXXConstructorName:
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
-    AddTypeSourceInfo(DNLoc.getNamedTypeInfo());
+    AddTypeSourceInfo(DNLoc.getNamedTypeInfo(), Seq);
     break;
 
   case DeclarationName::CXXOperatorName:
-    AddSourceRange(DNLoc.getCXXOperatorNameRange());
+    AddSourceRange(DNLoc.getCXXOperatorNameRange(), Seq);
     break;
 
   case DeclarationName::CXXLiteralOperatorName:
-    AddSourceLocation(DNLoc.getCXXLiteralOperatorNameLoc());
+    AddSourceLocation(DNLoc.getCXXLiteralOperatorNameLoc(), Seq);
     break;
 
   case DeclarationName::Identifier:
   case DeclarationName::ObjCZeroArgSelector:
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector:
   case DeclarationName::CXXUsingDirective:
   case DeclarationName::CXXDeductionGuideName:
     break;
   }
 }
 
 void ASTRecordWriter::AddDeclarationNameInfo(
     const DeclarationNameInfo &NameInfo) {
   AddDeclarationName(NameInfo.getName());
   AddSourceLocation(NameInfo.getLoc());
   AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName());
 }
 
-void ASTRecordWriter::AddQualifierInfo(const QualifierInfo &Info) {
-  AddNestedNameSpecifierLoc(Info.QualifierLoc);
+void ASTRecordWriter::AddQualifierInfo(const QualifierInfo &Info,
+                                       SourceLocationSeq *Seq) {
+  AddNestedNameSpecifierLoc(Info.QualifierLoc, Seq);
   Record->push_back(Info.NumTemplParamLists);
   for (unsigned i = 0, e = Info.NumTemplParamLists; i != e; ++i)
-    AddTemplateParameterList(Info.TemplParamLists[i]);
+    AddTemplateParameterList(Info.TemplParamLists[i], Seq);
 }
 
-void ASTRecordWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
+void ASTRecordWriter::AddNestedNameSpecifierLoc(
+    NestedNameSpecifierLoc NNS, serialization::SourceLocationSeq *OuterSeq) {
+  SourceLocationSeqRoot Seq(OuterSeq);
   // Nested name specifiers usually aren't too long. I think that 8 would
   // typically accommodate the vast majority.
   SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
 
   // Push each of the nested-name-specifiers's onto a stack for
   // serialization in reverse order.
   while (NNS) {
     NestedNames.push_back(NNS);
     NNS = NNS.getPrefix();
   }
 
   Record->push_back(NestedNames.size());
   while(!NestedNames.empty()) {
     NNS = NestedNames.pop_back_val();
     NestedNameSpecifier::SpecifierKind Kind
       = NNS.getNestedNameSpecifier()->getKind();
     Record->push_back(Kind);
     switch (Kind) {
     case NestedNameSpecifier::Identifier:
       AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier());
-      AddSourceRange(NNS.getLocalSourceRange());
+      AddSourceRange(NNS.getLocalSourceRange(), Seq);
       break;
 
     case NestedNameSpecifier::Namespace:
       AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace());
-      AddSourceRange(NNS.getLocalSourceRange());
+      AddSourceRange(NNS.getLocalSourceRange(), Seq);
       break;
 
     case NestedNameSpecifier::NamespaceAlias:
       AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias());
-      AddSourceRange(NNS.getLocalSourceRange());
+      AddSourceRange(NNS.getLocalSourceRange(), Seq);
       break;
 
     case NestedNameSpecifier::TypeSpec:
     case NestedNameSpecifier::TypeSpecWithTemplate:
       Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
       AddTypeRef(NNS.getTypeLoc().getType());
-      AddTypeLoc(NNS.getTypeLoc());
-      AddSourceLocation(NNS.getLocalSourceRange().getEnd());
+      AddTypeLoc(NNS.getTypeLoc(), Seq);
+      AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Seq);
       break;
 
     case NestedNameSpecifier::Global:
-      AddSourceLocation(NNS.getLocalSourceRange().getEnd());
+      AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Seq);
       break;
 
     case NestedNameSpecifier::Super:
       AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl());
-      AddSourceRange(NNS.getLocalSourceRange());
+      AddSourceRange(NNS.getLocalSourceRange(), Seq);
       break;
     }
   }
 }
 
 void ASTRecordWriter::AddTemplateParameterList(
-    const TemplateParameterList *TemplateParams) {
+    const TemplateParameterList *TemplateParams, SourceLocationSeq *Seq) {
   assert(TemplateParams && "No TemplateParams!");
-  AddSourceLocation(TemplateParams->getTemplateLoc());
-  AddSourceLocation(TemplateParams->getLAngleLoc());
-  AddSourceLocation(TemplateParams->getRAngleLoc());
+  AddSourceLocation(TemplateParams->getTemplateLoc(), Seq);
+  AddSourceLocation(TemplateParams->getLAngleLoc(), Seq);
+  AddSourceLocation(TemplateParams->getRAngleLoc(), Seq);
 
   Record->push_back(TemplateParams->size());
   for (const auto &P : *TemplateParams)
     AddDeclRef(P);
   if (const Expr *RequiresClause = TemplateParams->getRequiresClause()) {
     Record->push_back(true);
     AddStmt(const_cast<Expr*>(RequiresClause));
   } else {

clang/lib/Serialization/ASTWriterDecl.cpp

public:
     void VisitVarTemplatePartialSpecializationDecl(
         VarTemplatePartialSpecializationDecl *D);
     void VisitClassScopeFunctionSpecializationDecl(
                                        ClassScopeFunctionSpecializationDecl *D);
     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
     void VisitValueDecl(ValueDecl *D);
     void VisitEnumConstantDecl(EnumConstantDecl *D);
     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
-    void VisitDeclaratorDecl(DeclaratorDecl *D);
+    void VisitDeclaratorDecl(DeclaratorDecl *D,
+                             serialization::SourceLocationSeq *Seq = nullptr);
     void VisitFunctionDecl(FunctionDecl *D);
     void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
     void VisitCXXMethodDecl(CXXMethodDecl *D);
     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
     void VisitCXXConversionDecl(CXXConversionDecl *D);
     void VisitFieldDecl(FieldDecl *D);
     void VisitMSPropertyDecl(MSPropertyDecl *D);
void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   Record.push_back(D->getInitExpr()? 1 : 0);
   if (D->getInitExpr())
     Record.AddStmt(D->getInitExpr());
   Record.AddAPSInt(D->getInitVal());
 
   Code = serialization::DECL_ENUM_CONSTANT;
 }
 
-void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
+void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D,
+                                        serialization::SourceLocationSeq *Seq) {
   VisitValueDecl(D);
-  Record.AddSourceLocation(D->getInnerLocStart());
+  Record.AddSourceLocation(D->getInnerLocStart(), Seq);
   Record.push_back(D->hasExtInfo());
   if (D->hasExtInfo()) {
     DeclaratorDecl::ExtInfo *Info = D->getExtInfo();
-    Record.AddQualifierInfo(*Info);
+    Record.AddQualifierInfo(*Info, Seq);
     Record.AddStmt(Info->TrailingRequiresClause);
   }
   // The location information is deferred until the end of the record.
   Record.AddTypeRef(D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
                                            : QualType());
 }
 
 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
+  SourceLocationSeqRoot Seq;
   VisitRedeclarable(D);
-  VisitDeclaratorDecl(D);
-  Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
+  VisitDeclaratorDecl(D, Seq);
+  Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Seq);
   Record.push_back(D->getIdentifierNamespace());
 
   // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
   // after everything else is written.
   Record.push_back(static_cast<int>(D->getStorageClass())); // FIXME: stable encoding
   Record.push_back(D->isInlineSpecified());
   Record.push_back(D->isInlined());
   Record.push_back(D->isVirtualAsWritten());
   Record.push_back(D->isPure());
   Record.push_back(D->hasInheritedPrototype());
   Record.push_back(D->hasWrittenPrototype());
   Record.push_back(D->isDeletedBit());
   Record.push_back(D->isTrivial());
   Record.push_back(D->isTrivialForCall());
   Record.push_back(D->isDefaulted());
   Record.push_back(D->isExplicitlyDefaulted());
   Record.push_back(D->hasImplicitReturnZero());
   Record.push_back(static_cast<uint64_t>(D->getConstexprKind()));
   Record.push_back(D->usesSEHTry());
   Record.push_back(D->hasSkippedBody());
   Record.push_back(D->isMultiVersion());
   Record.push_back(D->isLateTemplateParsed());
   Record.push_back(D->getLinkageInternal());
-  Record.AddSourceLocation(D->getEndLoc());
+  Record.AddSourceLocation(D->getEndLoc(), Seq);
 
   Record.push_back(D->getODRHash());
 
   if (D->isDefaulted()) {
     if (auto *FDI = D->getDefaultedFunctionInfo()) {
       Record.push_back(FDI->getUnqualifiedLookups().size());
       for (DeclAccessPair P : FDI->getUnqualifiedLookups()) {
         Record.AddDeclRef(P.getDecl());
case FunctionDecl::TK_NonTemplate:
     break;
   case FunctionDecl::TK_FunctionTemplate:
     Record.AddDeclRef(D->getDescribedFunctionTemplate());
     break;
   case FunctionDecl::TK_MemberSpecialization: {
     MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
     Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
     Record.push_back(MemberInfo->getTemplateSpecializationKind());
-    Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
+    Record.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Seq);
     break;
   }
   case FunctionDecl::TK_FunctionTemplateSpecialization: {
     FunctionTemplateSpecializationInfo *
       FTSInfo = D->getTemplateSpecializationInfo();
 
     RegisterTemplateSpecialization(FTSInfo->getTemplate(), D);
 
     Record.AddDeclRef(FTSInfo->getTemplate());
     Record.push_back(FTSInfo->getTemplateSpecializationKind());
 
     // Template arguments.
     Record.AddTemplateArgumentList(FTSInfo->TemplateArguments);
 
     // Template args as written.
     Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr);
     if (FTSInfo->TemplateArgumentsAsWritten) {
       Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
       for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
              i!=e; ++i)
         Record.AddTemplateArgumentLoc(
-            (*FTSInfo->TemplateArgumentsAsWritten)[i]);
-      Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc);
-      Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc);
+            (*FTSInfo->TemplateArgumentsAsWritten)[i]); // FIXME: seq
+      Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc, Seq);
+      Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc, Seq);
     }
 
-    Record.AddSourceLocation(FTSInfo->getPointOfInstantiation());
+    Record.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Seq);
 
     if (MemberSpecializationInfo *MemberInfo =
         FTSInfo->getMemberSpecializationInfo()) {
       Record.push_back(1);
       Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
       Record.push_back(MemberInfo->getTemplateSpecializationKind());
-      Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
+      Record.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Seq);
     } else {
       Record.push_back(0);
     }
 
     if (D->isCanonicalDecl()) {
       // Write the template that contains the specializations set. We will
       // add a FunctionTemplateSpecializationInfo to it when reading.
       Record.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl());
     }
     break;
   }
   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     DependentFunctionTemplateSpecializationInfo *
       DFTSInfo = D->getDependentSpecializationInfo();
 
     // Templates.
     Record.push_back(DFTSInfo->getNumTemplates());
     for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
       Record.AddDeclRef(DFTSInfo->getTemplate(i));
 
     // Templates args.
     Record.push_back(DFTSInfo->getNumTemplateArgs());
     for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
-      Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i));
-    Record.AddSourceLocation(DFTSInfo->getLAngleLoc());
-    Record.AddSourceLocation(DFTSInfo->getRAngleLoc());
+      Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i)); // FIXME: seq
+    Record.AddSourceLocation(DFTSInfo->getLAngleLoc(), Seq);
+    Record.AddSourceLocation(DFTSInfo->getRAngleLoc(), Seq);
     break;
   }
   }
 
   Record.push_back(D->param_size());
   for (auto P : D->parameters())
     Record.AddDeclRef(P);
   Code = serialization::DECL_FUNCTION;

clang/lib/Serialization/ASTWriterStmt.cpp

 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
   VisitBinaryOperator(E);
   Record.AddTypeRef(E->getComputationLHSType());
   Record.AddTypeRef(E->getComputationResultType());
   Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
 }
 
 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
+  serialization::SourceLocationSeq Seq;
   VisitExpr(E);
   Record.AddStmt(E->getCond());
   Record.AddStmt(E->getLHS());
   Record.AddStmt(E->getRHS());
-  Record.AddSourceLocation(E->getQuestionLoc());
-  Record.AddSourceLocation(E->getColonLoc());
+  Record.AddSourceLocation(E->getQuestionLoc(), &Seq);
+  Record.AddSourceLocation(E->getColonLoc(), &Seq);
   Code = serialization::EXPR_CONDITIONAL_OPERATOR;
 }
 
 void
 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
+  serialization::SourceLocationSeq Seq;
   VisitExpr(E);
   Record.AddStmt(E->getOpaqueValue());
   Record.AddStmt(E->getCommon());
   Record.AddStmt(E->getCond());
   Record.AddStmt(E->getTrueExpr());
   Record.AddStmt(E->getFalseExpr());
-  Record.AddSourceLocation(E->getQuestionLoc());
-  Record.AddSourceLocation(E->getColonLoc());
+  Record.AddSourceLocation(E->getQuestionLoc(), &Seq);
+  Record.AddSourceLocation(E->getColonLoc(), &Seq);
   Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
 }
 
 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
   VisitCastExpr(E);
   Record.push_back(E->isPartOfExplicitCast());
 
   if (E->path_size() == 0 && !E->hasStoredFPFeatures())
     AbbrevToUse = Writer.getExprImplicitCastAbbrev();
 
   Code = serialization::EXPR_IMPLICIT_CAST;
 }
 
 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   VisitCastExpr(E);
   Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
 }
 
 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
+  serialization::SourceLocationSeq Seq;
   VisitExplicitCastExpr(E);
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceLocation(E->getLParenLoc(), &Seq);
+  Record.AddSourceLocation(E->getRParenLoc(), &Seq);
   Code = serialization::EXPR_CSTYLE_CAST;
 }
 
 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   Record.AddSourceLocation(E->getLParenLoc());
   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
   Record.AddStmt(E->getInitializer());

clang/unittests/Serialization/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BitReader
   BitstreamReader
   Support
   )
 
 add_clang_unittest(SerializationTests
   InMemoryModuleCacheTest.cpp
   ModuleCacheTest.cpp
+  SourceLocationEncodingTest.cpp
   )
 
 clang_target_link_libraries(SerializationTests
   PRIVATE
   clangAST
   clangBasic
   clangFrontend
   clangLex
   clangSema
   clangSerialization
   )

clang/unittests/Serialization/SourceLocationEncodingTest.cpp

+//===- unittests/Serialization/SourceLocationEncodingTests.cpp ------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Serialization/SourceLocationEncoding.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace clang;
+
+namespace {
+
+void roundTrip(std::vector<SourceLocation::UIntTy> Locs,
+               std::vector<uint64_t> ExpectedEncoded = {}) {
+  serialization::SourceLocationSeq Seq;
+  std::vector<uint64_t> ActualEncoded;
+  for (auto L : Locs)
+    ActualEncoded.push_back(Seq.encodeRaw(L));
+  if (!ExpectedEncoded.empty())
+    ASSERT_EQ(ActualEncoded, ExpectedEncoded)
+        << "Encoding " << testing::PrintToString(Locs);
+  Seq = serialization::SourceLocationSeq();
+  std::vector<SourceLocation::UIntTy> DecodedEncoded;
+  for (auto L : ActualEncoded)
+    DecodedEncoded.push_back(Seq.decodeRaw(L));
+  ASSERT_EQ(DecodedEncoded, Locs)
+      << "Decoding " << testing::PrintToString(ActualEncoded);
+}
+
+TEST(SourceLocationEncoding, RoundTrips) {
+  roundTrip({1, 2, 3, 3, 2, 1},
+            {2, // 1
+             5, // +1
+             5, // +1
+             1, // +0
+             3, // -1
+             3} // -1
+  );
+  roundTrip({100, 0, 100},
+            {200, // 100
+             0,   // 0
+             1}   // +0
+  );
+
+  SourceLocation::UIntTy MacroBit =
+      1 << (sizeof(SourceLocation::UIntTy) * CHAR_BIT - 1);
+  roundTrip({1, MacroBit | 5, MacroBit | 4, 3}, {2,
+                                                 22, // =5|MacroBit
+                                                 3,  // -1
+                                                 12} // =3
+  );
+
+  unsigned Big = 1 << 20;
+  roundTrip({123 | MacroBit, 1, 9, Big, Big + 1, 0, MacroBit | Big, 0});
+}
+
+} // namespace