clang  7.0.0svn
ASTWriter.cpp
Go to the documentation of this file.
1 //===- ASTWriter.cpp - AST File Writer ------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the ASTWriter class, which writes AST files.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "MultiOnDiskHashTable.h"
18 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/Attr.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
25 #include "clang/AST/DeclFriend.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
29 #include "clang/AST/Expr.h"
30 #include "clang/AST/ExprCXX.h"
34 #include "clang/AST/TemplateName.h"
35 #include "clang/AST/Type.h"
37 #include "clang/Basic/Diagnostic.h"
42 #include "clang/Basic/LLVM.h"
43 #include "clang/Basic/Lambda.h"
46 #include "clang/Basic/Module.h"
52 #include "clang/Basic/Specifiers.h"
53 #include "clang/Basic/TargetInfo.h"
55 #include "clang/Basic/Version.h"
57 #include "clang/Lex/HeaderSearch.h"
59 #include "clang/Lex/MacroInfo.h"
60 #include "clang/Lex/ModuleMap.h"
62 #include "clang/Lex/Preprocessor.h"
64 #include "clang/Lex/Token.h"
67 #include "clang/Sema/Sema.h"
68 #include "clang/Sema/Weak.h"
73 #include "llvm/ADT/APFloat.h"
74 #include "llvm/ADT/APInt.h"
75 #include "llvm/ADT/APSInt.h"
76 #include "llvm/ADT/ArrayRef.h"
77 #include "llvm/ADT/DenseMap.h"
78 #include "llvm/ADT/Hashing.h"
79 #include "llvm/ADT/Optional.h"
80 #include "llvm/ADT/PointerIntPair.h"
81 #include "llvm/ADT/STLExtras.h"
82 #include "llvm/ADT/SmallSet.h"
83 #include "llvm/ADT/SmallString.h"
84 #include "llvm/ADT/SmallVector.h"
85 #include "llvm/ADT/StringMap.h"
86 #include "llvm/ADT/StringRef.h"
87 #include "llvm/Bitcode/BitCodes.h"
88 #include "llvm/Bitcode/BitstreamWriter.h"
89 #include "llvm/Support/Casting.h"
90 #include "llvm/Support/Compression.h"
91 #include "llvm/Support/DJB.h"
92 #include "llvm/Support/Endian.h"
93 #include "llvm/Support/EndianStream.h"
94 #include "llvm/Support/Error.h"
95 #include "llvm/Support/ErrorHandling.h"
96 #include "llvm/Support/MemoryBuffer.h"
97 #include "llvm/Support/OnDiskHashTable.h"
98 #include "llvm/Support/Path.h"
99 #include "llvm/Support/SHA1.h"
100 #include "llvm/Support/raw_ostream.h"
101 #include <algorithm>
102 #include <cassert>
103 #include <cstdint>
104 #include <cstdlib>
105 #include <cstring>
106 #include <ctime>
107 #include <deque>
108 #include <limits>
109 #include <memory>
110 #include <queue>
111 #include <tuple>
112 #include <utility>
113 #include <vector>
114 
115 using namespace clang;
116 using namespace clang::serialization;
117 
118 template <typename T, typename Allocator>
119 static StringRef bytes(const std::vector<T, Allocator> &v) {
120  if (v.empty()) return StringRef();
121  return StringRef(reinterpret_cast<const char*>(&v[0]),
122  sizeof(T) * v.size());
123 }
124 
125 template <typename T>
126 static StringRef bytes(const SmallVectorImpl<T> &v) {
127  return StringRef(reinterpret_cast<const char*>(v.data()),
128  sizeof(T) * v.size());
129 }
130 
131 //===----------------------------------------------------------------------===//
132 // Type serialization
133 //===----------------------------------------------------------------------===//
134 
135 namespace clang {
136 
138  ASTWriter &Writer;
139  ASTRecordWriter Record;
140 
141  /// Type code that corresponds to the record generated.
142  TypeCode Code = static_cast<TypeCode>(0);
143 
144  /// Abbreviation to use for the record, if any.
145  unsigned AbbrevToUse = 0;
146 
147  public:
149  : Writer(Writer), Record(Writer, Record) {}
150 
151  uint64_t Emit() {
152  return Record.Emit(Code, AbbrevToUse);
153  }
154 
155  void Visit(QualType T) {
156  if (T.hasLocalNonFastQualifiers()) {
159  Record.push_back(Qs.getAsOpaqueValue());
160  Code = TYPE_EXT_QUAL;
161  AbbrevToUse = Writer.TypeExtQualAbbrev;
162  } else {
163  switch (T->getTypeClass()) {
164  // For all of the concrete, non-dependent types, call the
165  // appropriate visitor function.
166 #define TYPE(Class, Base) \
167  case Type::Class: Visit##Class##Type(cast<Class##Type>(T)); break;
168 #define ABSTRACT_TYPE(Class, Base)
169 #include "clang/AST/TypeNodes.def"
170  }
171  }
172  }
173 
174  void VisitArrayType(const ArrayType *T);
175  void VisitFunctionType(const FunctionType *T);
176  void VisitTagType(const TagType *T);
177 
178 #define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T);
179 #define ABSTRACT_TYPE(Class, Base)
180 #include "clang/AST/TypeNodes.def"
181  };
182 
183 } // namespace clang
184 
185 void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {
186  llvm_unreachable("Built-in types are never serialized");
187 }
188 
189 void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
190  Record.AddTypeRef(T->getElementType());
191  Code = TYPE_COMPLEX;
192 }
193 
194 void ASTTypeWriter::VisitPointerType(const PointerType *T) {
195  Record.AddTypeRef(T->getPointeeType());
196  Code = TYPE_POINTER;
197 }
198 
199 void ASTTypeWriter::VisitDecayedType(const DecayedType *T) {
200  Record.AddTypeRef(T->getOriginalType());
201  Code = TYPE_DECAYED;
202 }
203 
204 void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) {
205  Record.AddTypeRef(T->getOriginalType());
206  Record.AddTypeRef(T->getAdjustedType());
207  Code = TYPE_ADJUSTED;
208 }
209 
210 void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
211  Record.AddTypeRef(T->getPointeeType());
212  Code = TYPE_BLOCK_POINTER;
213 }
214 
215 void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
216  Record.AddTypeRef(T->getPointeeTypeAsWritten());
217  Record.push_back(T->isSpelledAsLValue());
218  Code = TYPE_LVALUE_REFERENCE;
219 }
220 
221 void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) {
222  Record.AddTypeRef(T->getPointeeTypeAsWritten());
223  Code = TYPE_RVALUE_REFERENCE;
224 }
225 
226 void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) {
227  Record.AddTypeRef(T->getPointeeType());
228  Record.AddTypeRef(QualType(T->getClass(), 0));
229  Code = TYPE_MEMBER_POINTER;
230 }
231 
233  Record.AddTypeRef(T->getElementType());
234  Record.push_back(T->getSizeModifier()); // FIXME: stable values
235  Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values
236 }
237 
238 void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
239  VisitArrayType(T);
240  Record.AddAPInt(T->getSize());
241  Code = TYPE_CONSTANT_ARRAY;
242 }
243 
244 void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
245  VisitArrayType(T);
246  Code = TYPE_INCOMPLETE_ARRAY;
247 }
248 
249 void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
250  VisitArrayType(T);
251  Record.AddSourceLocation(T->getLBracketLoc());
252  Record.AddSourceLocation(T->getRBracketLoc());
253  Record.AddStmt(T->getSizeExpr());
254  Code = TYPE_VARIABLE_ARRAY;
255 }
256 
257 void ASTTypeWriter::VisitVectorType(const VectorType *T) {
258  Record.AddTypeRef(T->getElementType());
259  Record.push_back(T->getNumElements());
260  Record.push_back(T->getVectorKind());
261  Code = TYPE_VECTOR;
262 }
263 
264 void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) {
265  VisitVectorType(T);
266  Code = TYPE_EXT_VECTOR;
267 }
268 
270  Record.AddTypeRef(T->getReturnType());
272  Record.push_back(C.getNoReturn());
273  Record.push_back(C.getHasRegParm());
274  Record.push_back(C.getRegParm());
275  // FIXME: need to stabilize encoding of calling convention...
276  Record.push_back(C.getCC());
277  Record.push_back(C.getProducesResult());
278  Record.push_back(C.getNoCallerSavedRegs());
279  Record.push_back(C.getNoCfCheck());
280 
281  if (C.getHasRegParm() || C.getRegParm() || C.getProducesResult())
282  AbbrevToUse = 0;
283 }
284 
285 void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
286  VisitFunctionType(T);
287  Code = TYPE_FUNCTION_NO_PROTO;
288 }
289 
290 static void addExceptionSpec(const FunctionProtoType *T,
291  ASTRecordWriter &Record) {
292  Record.push_back(T->getExceptionSpecType());
293  if (T->getExceptionSpecType() == EST_Dynamic) {
294  Record.push_back(T->getNumExceptions());
295  for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
296  Record.AddTypeRef(T->getExceptionType(I));
297  } else if (isComputedNoexcept(T->getExceptionSpecType())) {
298  Record.AddStmt(T->getNoexceptExpr());
299  } else if (T->getExceptionSpecType() == EST_Uninstantiated) {
300  Record.AddDeclRef(T->getExceptionSpecDecl());
302  } else if (T->getExceptionSpecType() == EST_Unevaluated) {
303  Record.AddDeclRef(T->getExceptionSpecDecl());
304  }
305 }
306 
307 void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) {
308  VisitFunctionType(T);
309 
310  Record.push_back(T->isVariadic());
311  Record.push_back(T->hasTrailingReturn());
312  Record.push_back(T->getTypeQuals());
313  Record.push_back(static_cast<unsigned>(T->getRefQualifier()));
314  addExceptionSpec(T, Record);
315 
316  Record.push_back(T->getNumParams());
317  for (unsigned I = 0, N = T->getNumParams(); I != N; ++I)
318  Record.AddTypeRef(T->getParamType(I));
319 
320  if (T->hasExtParameterInfos()) {
321  for (unsigned I = 0, N = T->getNumParams(); I != N; ++I)
322  Record.push_back(T->getExtParameterInfo(I).getOpaqueValue());
323  }
324 
325  if (T->isVariadic() || T->hasTrailingReturn() || T->getTypeQuals() ||
328  AbbrevToUse = 0;
329 
330  Code = TYPE_FUNCTION_PROTO;
331 }
332 
333 void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
334  Record.AddDeclRef(T->getDecl());
335  Code = TYPE_UNRESOLVED_USING;
336 }
337 
338 void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
339  Record.AddDeclRef(T->getDecl());
340  assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
341  Record.AddTypeRef(T->getCanonicalTypeInternal());
342  Code = TYPE_TYPEDEF;
343 }
344 
345 void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
346  Record.AddStmt(T->getUnderlyingExpr());
347  Code = TYPE_TYPEOF_EXPR;
348 }
349 
350 void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
351  Record.AddTypeRef(T->getUnderlyingType());
352  Code = TYPE_TYPEOF;
353 }
354 
355 void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
356  Record.AddTypeRef(T->getUnderlyingType());
357  Record.AddStmt(T->getUnderlyingExpr());
358  Code = TYPE_DECLTYPE;
359 }
360 
361 void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
362  Record.AddTypeRef(T->getBaseType());
363  Record.AddTypeRef(T->getUnderlyingType());
364  Record.push_back(T->getUTTKind());
365  Code = TYPE_UNARY_TRANSFORM;
366 }
367 
368 void ASTTypeWriter::VisitAutoType(const AutoType *T) {
369  Record.AddTypeRef(T->getDeducedType());
370  Record.push_back((unsigned)T->getKeyword());
371  if (T->getDeducedType().isNull())
372  Record.push_back(T->isDependentType());
373  Code = TYPE_AUTO;
374 }
375 
376 void ASTTypeWriter::VisitDeducedTemplateSpecializationType(
378  Record.AddTemplateName(T->getTemplateName());
379  Record.AddTypeRef(T->getDeducedType());
380  if (T->getDeducedType().isNull())
381  Record.push_back(T->isDependentType());
383 }
384 
386  Record.push_back(T->isDependentType());
387  Record.AddDeclRef(T->getDecl()->getCanonicalDecl());
388  assert(!T->isBeingDefined() &&
389  "Cannot serialize in the middle of a type definition");
390 }
391 
392 void ASTTypeWriter::VisitRecordType(const RecordType *T) {
393  VisitTagType(T);
394  Code = TYPE_RECORD;
395 }
396 
397 void ASTTypeWriter::VisitEnumType(const EnumType *T) {
398  VisitTagType(T);
399  Code = TYPE_ENUM;
400 }
401 
402 void ASTTypeWriter::VisitAttributedType(const AttributedType *T) {
403  Record.AddTypeRef(T->getModifiedType());
404  Record.AddTypeRef(T->getEquivalentType());
405  Record.push_back(T->getAttrKind());
406  Code = TYPE_ATTRIBUTED;
407 }
408 
409 void
410 ASTTypeWriter::VisitSubstTemplateTypeParmType(
411  const SubstTemplateTypeParmType *T) {
412  Record.AddTypeRef(QualType(T->getReplacedParameter(), 0));
413  Record.AddTypeRef(T->getReplacementType());
415 }
416 
417 void
418 ASTTypeWriter::VisitSubstTemplateTypeParmPackType(
420  Record.AddTypeRef(QualType(T->getReplacedParameter(), 0));
421  Record.AddTemplateArgument(T->getArgumentPack());
423 }
424 
425 void
426 ASTTypeWriter::VisitTemplateSpecializationType(
427  const TemplateSpecializationType *T) {
428  Record.push_back(T->isDependentType());
429  Record.AddTemplateName(T->getTemplateName());
430  Record.push_back(T->getNumArgs());
431  for (const auto &ArgI : *T)
432  Record.AddTemplateArgument(ArgI);
433  Record.AddTypeRef(T->isTypeAlias() ? T->getAliasedType()
434  : T->isCanonicalUnqualified()
435  ? QualType()
436  : T->getCanonicalTypeInternal());
438 }
439 
440 void
441 ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
442  VisitArrayType(T);
443  Record.AddStmt(T->getSizeExpr());
444  Record.AddSourceRange(T->getBracketsRange());
446 }
447 
448 void
449 ASTTypeWriter::VisitDependentSizedExtVectorType(
450  const DependentSizedExtVectorType *T) {
451  Record.AddTypeRef(T->getElementType());
452  Record.AddStmt(T->getSizeExpr());
453  Record.AddSourceLocation(T->getAttributeLoc());
455 }
456 
457 void
458 ASTTypeWriter::VisitDependentAddressSpaceType(
459  const DependentAddressSpaceType *T) {
460  Record.AddTypeRef(T->getPointeeType());
461  Record.AddStmt(T->getAddrSpaceExpr());
462  Record.AddSourceLocation(T->getAttributeLoc());
464 }
465 
466 void
467 ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
468  Record.push_back(T->getDepth());
469  Record.push_back(T->getIndex());
470  Record.push_back(T->isParameterPack());
471  Record.AddDeclRef(T->getDecl());
473 }
474 
475 void
476 ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) {
477  Record.push_back(T->getKeyword());
478  Record.AddNestedNameSpecifier(T->getQualifier());
479  Record.AddIdentifierRef(T->getIdentifier());
480  Record.AddTypeRef(
482  Code = TYPE_DEPENDENT_NAME;
483 }
484 
485 void
486 ASTTypeWriter::VisitDependentTemplateSpecializationType(
488  Record.push_back(T->getKeyword());
489  Record.AddNestedNameSpecifier(T->getQualifier());
490  Record.AddIdentifierRef(T->getIdentifier());
491  Record.push_back(T->getNumArgs());
492  for (const auto &I : *T)
493  Record.AddTemplateArgument(I);
495 }
496 
497 void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
498  Record.AddTypeRef(T->getPattern());
499  if (Optional<unsigned> NumExpansions = T->getNumExpansions())
500  Record.push_back(*NumExpansions + 1);
501  else
502  Record.push_back(0);
503  Code = TYPE_PACK_EXPANSION;
504 }
505 
506 void ASTTypeWriter::VisitParenType(const ParenType *T) {
507  Record.AddTypeRef(T->getInnerType());
508  Code = TYPE_PAREN;
509 }
510 
511 void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
512  Record.push_back(T->getKeyword());
513  Record.AddNestedNameSpecifier(T->getQualifier());
514  Record.AddTypeRef(T->getNamedType());
515  Record.AddDeclRef(T->getOwnedTagDecl());
516  Code = TYPE_ELABORATED;
517 }
518 
519 void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
520  Record.AddDeclRef(T->getDecl()->getCanonicalDecl());
521  Record.AddTypeRef(T->getInjectedSpecializationType());
523 }
524 
525 void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
526  Record.AddDeclRef(T->getDecl()->getCanonicalDecl());
527  Code = TYPE_OBJC_INTERFACE;
528 }
529 
530 void ASTTypeWriter::VisitObjCTypeParamType(const ObjCTypeParamType *T) {
531  Record.AddDeclRef(T->getDecl());
532  Record.push_back(T->getNumProtocols());
533  for (const auto *I : T->quals())
534  Record.AddDeclRef(I);
535  Code = TYPE_OBJC_TYPE_PARAM;
536 }
537 
538 void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
539  Record.AddTypeRef(T->getBaseType());
540  Record.push_back(T->getTypeArgsAsWritten().size());
541  for (auto TypeArg : T->getTypeArgsAsWritten())
542  Record.AddTypeRef(TypeArg);
543  Record.push_back(T->getNumProtocols());
544  for (const auto *I : T->quals())
545  Record.AddDeclRef(I);
546  Record.push_back(T->isKindOfTypeAsWritten());
547  Code = TYPE_OBJC_OBJECT;
548 }
549 
550 void
551 ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
552  Record.AddTypeRef(T->getPointeeType());
554 }
555 
556 void
557 ASTTypeWriter::VisitAtomicType(const AtomicType *T) {
558  Record.AddTypeRef(T->getValueType());
559  Code = TYPE_ATOMIC;
560 }
561 
562 void
563 ASTTypeWriter::VisitPipeType(const PipeType *T) {
564  Record.AddTypeRef(T->getElementType());
565  Record.push_back(T->isReadOnly());
566  Code = TYPE_PIPE;
567 }
568 
569 namespace {
570 
571 class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
572  ASTRecordWriter &Record;
573 
574 public:
575  TypeLocWriter(ASTRecordWriter &Record) : Record(Record) {}
576 
577 #define ABSTRACT_TYPELOC(CLASS, PARENT)
578 #define TYPELOC(CLASS, PARENT) \
579  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
580 #include "clang/AST/TypeLocNodes.def"
581 
582  void VisitArrayTypeLoc(ArrayTypeLoc TyLoc);
583  void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc);
584 };
585 
586 } // namespace
587 
588 void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
589  // nothing to do
590 }
591 
592 void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
593  Record.AddSourceLocation(TL.getBuiltinLoc());
594  if (TL.needsExtraLocalData()) {
595  Record.push_back(TL.getWrittenTypeSpec());
596  Record.push_back(TL.getWrittenSignSpec());
597  Record.push_back(TL.getWrittenWidthSpec());
598  Record.push_back(TL.hasModeAttr());
599  }
600 }
601 
602 void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
603  Record.AddSourceLocation(TL.getNameLoc());
604 }
605 
606 void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
607  Record.AddSourceLocation(TL.getStarLoc());
608 }
609 
610 void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
611  // nothing to do
612 }
613 
614 void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
615  // nothing to do
616 }
617 
618 void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
619  Record.AddSourceLocation(TL.getCaretLoc());
620 }
621 
622 void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
623  Record.AddSourceLocation(TL.getAmpLoc());
624 }
625 
626 void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
627  Record.AddSourceLocation(TL.getAmpAmpLoc());
628 }
629 
630 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
631  Record.AddSourceLocation(TL.getStarLoc());
632  Record.AddTypeSourceInfo(TL.getClassTInfo());
633 }
634 
635 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
636  Record.AddSourceLocation(TL.getLBracketLoc());
637  Record.AddSourceLocation(TL.getRBracketLoc());
638  Record.push_back(TL.getSizeExpr() ? 1 : 0);
639  if (TL.getSizeExpr())
640  Record.AddStmt(TL.getSizeExpr());
641 }
642 
643 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
644  VisitArrayTypeLoc(TL);
645 }
646 
647 void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
648  VisitArrayTypeLoc(TL);
649 }
650 
651 void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
652  VisitArrayTypeLoc(TL);
653 }
654 
655 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
657  VisitArrayTypeLoc(TL);
658 }
659 
660 void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
662  Record.AddSourceLocation(TL.getAttrNameLoc());
664  Record.AddSourceLocation(range.getBegin());
665  Record.AddSourceLocation(range.getEnd());
666  Record.AddStmt(TL.getAttrExprOperand());
667 }
668 
669 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
671  Record.AddSourceLocation(TL.getNameLoc());
672 }
673 
674 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
675  Record.AddSourceLocation(TL.getNameLoc());
676 }
677 
678 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
679  Record.AddSourceLocation(TL.getNameLoc());
680 }
681 
682 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
683  Record.AddSourceLocation(TL.getLocalRangeBegin());
684  Record.AddSourceLocation(TL.getLParenLoc());
685  Record.AddSourceLocation(TL.getRParenLoc());
686  Record.AddSourceRange(TL.getExceptionSpecRange());
687  Record.AddSourceLocation(TL.getLocalRangeEnd());
688  for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
689  Record.AddDeclRef(TL.getParam(i));
690 }
691 
692 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
693  VisitFunctionTypeLoc(TL);
694 }
695 
696 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
697  VisitFunctionTypeLoc(TL);
698 }
699 
700 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
701  Record.AddSourceLocation(TL.getNameLoc());
702 }
703 
704 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
705  Record.AddSourceLocation(TL.getNameLoc());
706 }
707 
708 void TypeLocWriter::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
709  if (TL.getNumProtocols()) {
710  Record.AddSourceLocation(TL.getProtocolLAngleLoc());
711  Record.AddSourceLocation(TL.getProtocolRAngleLoc());
712  }
713  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
714  Record.AddSourceLocation(TL.getProtocolLoc(i));
715 }
716 
717 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
718  Record.AddSourceLocation(TL.getTypeofLoc());
719  Record.AddSourceLocation(TL.getLParenLoc());
720  Record.AddSourceLocation(TL.getRParenLoc());
721 }
722 
723 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
724  Record.AddSourceLocation(TL.getTypeofLoc());
725  Record.AddSourceLocation(TL.getLParenLoc());
726  Record.AddSourceLocation(TL.getRParenLoc());
727  Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
728 }
729 
730 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
731  Record.AddSourceLocation(TL.getNameLoc());
732 }
733 
734 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
735  Record.AddSourceLocation(TL.getKWLoc());
736  Record.AddSourceLocation(TL.getLParenLoc());
737  Record.AddSourceLocation(TL.getRParenLoc());
738  Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
739 }
740 
741 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
742  Record.AddSourceLocation(TL.getNameLoc());
743 }
744 
745 void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
747  Record.AddSourceLocation(TL.getTemplateNameLoc());
748 }
749 
750 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
751  Record.AddSourceLocation(TL.getNameLoc());
752 }
753 
754 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
755  Record.AddSourceLocation(TL.getNameLoc());
756 }
757 
758 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
759  Record.AddSourceLocation(TL.getAttrNameLoc());
760  if (TL.hasAttrOperand()) {
762  Record.AddSourceLocation(range.getBegin());
763  Record.AddSourceLocation(range.getEnd());
764  }
765  if (TL.hasAttrExprOperand()) {
766  Expr *operand = TL.getAttrExprOperand();
767  Record.push_back(operand ? 1 : 0);
768  if (operand) Record.AddStmt(operand);
769  } else if (TL.hasAttrEnumOperand()) {
770  Record.AddSourceLocation(TL.getAttrEnumOperandLoc());
771  }
772 }
773 
774 void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
775  Record.AddSourceLocation(TL.getNameLoc());
776 }
777 
778 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
780  Record.AddSourceLocation(TL.getNameLoc());
781 }
782 
783 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
785  Record.AddSourceLocation(TL.getNameLoc());
786 }
787 
788 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
790  Record.AddSourceLocation(TL.getTemplateKeywordLoc());
791  Record.AddSourceLocation(TL.getTemplateNameLoc());
792  Record.AddSourceLocation(TL.getLAngleLoc());
793  Record.AddSourceLocation(TL.getRAngleLoc());
794  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
795  Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
796  TL.getArgLoc(i).getLocInfo());
797 }
798 
799 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
800  Record.AddSourceLocation(TL.getLParenLoc());
801  Record.AddSourceLocation(TL.getRParenLoc());
802 }
803 
804 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
805  Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
806  Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
807 }
808 
809 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
810  Record.AddSourceLocation(TL.getNameLoc());
811 }
812 
813 void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
814  Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
815  Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
816  Record.AddSourceLocation(TL.getNameLoc());
817 }
818 
819 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
821  Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
822  Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
823  Record.AddSourceLocation(TL.getTemplateKeywordLoc());
824  Record.AddSourceLocation(TL.getTemplateNameLoc());
825  Record.AddSourceLocation(TL.getLAngleLoc());
826  Record.AddSourceLocation(TL.getRAngleLoc());
827  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
828  Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
829  TL.getArgLoc(I).getLocInfo());
830 }
831 
832 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
833  Record.AddSourceLocation(TL.getEllipsisLoc());
834 }
835 
836 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
837  Record.AddSourceLocation(TL.getNameLoc());
838 }
839 
840 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
841  Record.push_back(TL.hasBaseTypeAsWritten());
842  Record.AddSourceLocation(TL.getTypeArgsLAngleLoc());
843  Record.AddSourceLocation(TL.getTypeArgsRAngleLoc());
844  for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
845  Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i));
846  Record.AddSourceLocation(TL.getProtocolLAngleLoc());
847  Record.AddSourceLocation(TL.getProtocolRAngleLoc());
848  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
849  Record.AddSourceLocation(TL.getProtocolLoc(i));
850 }
851 
852 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
853  Record.AddSourceLocation(TL.getStarLoc());
854 }
855 
856 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
857  Record.AddSourceLocation(TL.getKWLoc());
858  Record.AddSourceLocation(TL.getLParenLoc());
859  Record.AddSourceLocation(TL.getRParenLoc());
860 }
861 
862 void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) {
863  Record.AddSourceLocation(TL.getKWLoc());
864 }
865 
866 void ASTWriter::WriteTypeAbbrevs() {
867  using namespace llvm;
868 
869  std::shared_ptr<BitCodeAbbrev> Abv;
870 
871  // Abbreviation for TYPE_EXT_QUAL
872  Abv = std::make_shared<BitCodeAbbrev>();
873  Abv->Add(BitCodeAbbrevOp(serialization::TYPE_EXT_QUAL));
874  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
875  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3)); // Quals
876  TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv));
877 
878  // Abbreviation for TYPE_FUNCTION_PROTO
879  Abv = std::make_shared<BitCodeAbbrev>();
880  Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO));
881  // FunctionType
882  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ReturnType
883  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn
884  Abv->Add(BitCodeAbbrevOp(0)); // HasRegParm
885  Abv->Add(BitCodeAbbrevOp(0)); // RegParm
886  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC
887  Abv->Add(BitCodeAbbrevOp(0)); // ProducesResult
888  Abv->Add(BitCodeAbbrevOp(0)); // NoCallerSavedRegs
889  Abv->Add(BitCodeAbbrevOp(0)); // NoCfCheck
890  // FunctionProtoType
891  Abv->Add(BitCodeAbbrevOp(0)); // IsVariadic
892  Abv->Add(BitCodeAbbrevOp(0)); // HasTrailingReturn
893  Abv->Add(BitCodeAbbrevOp(0)); // TypeQuals
894  Abv->Add(BitCodeAbbrevOp(0)); // RefQualifier
895  Abv->Add(BitCodeAbbrevOp(EST_None)); // ExceptionSpec
896  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumParams
897  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
898  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Params
899  TypeFunctionProtoAbbrev = Stream.EmitAbbrev(std::move(Abv));
900 }
901 
902 //===----------------------------------------------------------------------===//
903 // ASTWriter Implementation
904 //===----------------------------------------------------------------------===//
905 
906 static void EmitBlockID(unsigned ID, const char *Name,
907  llvm::BitstreamWriter &Stream,
908  ASTWriter::RecordDataImpl &Record) {
909  Record.clear();
910  Record.push_back(ID);
911  Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
912 
913  // Emit the block name if present.
914  if (!Name || Name[0] == 0)
915  return;
916  Record.clear();
917  while (*Name)
918  Record.push_back(*Name++);
919  Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
920 }
921 
922 static void EmitRecordID(unsigned ID, const char *Name,
923  llvm::BitstreamWriter &Stream,
924  ASTWriter::RecordDataImpl &Record) {
925  Record.clear();
926  Record.push_back(ID);
927  while (*Name)
928  Record.push_back(*Name++);
929  Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
930 }
931 
932 static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
933  ASTWriter::RecordDataImpl &Record) {
934 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
935  RECORD(STMT_STOP);
938  RECORD(STMT_NULL);
940  RECORD(STMT_CASE);
944  RECORD(STMT_IF);
947  RECORD(STMT_DO);
948  RECORD(STMT_FOR);
949  RECORD(STMT_GOTO);
954  RECORD(STMT_DECL);
969  RECORD(EXPR_CALL);
985  RECORD(EXPR_STMT);
1058 #undef RECORD
1059 }
1060 
1061 void ASTWriter::WriteBlockInfoBlock() {
1062  RecordData Record;
1063  Stream.EnterBlockInfoBlock();
1064 
1065 #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
1066 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
1067 
1068  // Control Block.
1069  BLOCK(CONTROL_BLOCK);
1070  RECORD(METADATA);
1074  RECORD(IMPORTS);
1079 
1080  BLOCK(OPTIONS_BLOCK);
1086 
1087  BLOCK(INPUT_FILES_BLOCK);
1088  RECORD(INPUT_FILE);
1089 
1090  // AST Top-Level Block.
1091  BLOCK(AST_BLOCK);
1099  RECORD(STATISTICS);
1144 
1145  // SourceManager Block.
1146  BLOCK(SOURCE_MANAGER_BLOCK);
1152 
1153  // Preprocessor Block.
1154  BLOCK(PREPROCESSOR_BLOCK);
1159  RECORD(PP_TOKEN);
1160 
1161  // Submodule Block.
1162  BLOCK(SUBMODULE_BLOCK);
1181 
1182  // Comments Block.
1183  BLOCK(COMMENTS_BLOCK);
1185 
1186  // Decls and Types block.
1187  BLOCK(DECLTYPES_BLOCK);
1206  RECORD(TYPE_ENUM);
1220  RECORD(TYPE_PAREN);
1224  RECORD(TYPE_AUTO);
1233  RECORD(DECL_ENUM);
1248  RECORD(DECL_FIELD);
1250  RECORD(DECL_VAR);
1254  RECORD(DECL_BLOCK);
1259  RECORD(DECL_USING);
1294  RECORD(DECL_EMPTY);
1300 
1301  // Statements and Exprs can occur in the Decls and Types block.
1302  AddStmtsExprs(Stream, Record);
1303 
1304  BLOCK(PREPROCESSOR_DETAIL_BLOCK);
1308 
1309  // Decls and Types block.
1310  BLOCK(EXTENSION_BLOCK);
1312 
1313  BLOCK(UNHASHED_CONTROL_BLOCK);
1314  RECORD(SIGNATURE);
1317 
1318 #undef RECORD
1319 #undef BLOCK
1320  Stream.ExitBlock();
1321 }
1322 
1323 /// Prepares a path for being written to an AST file by converting it
1324 /// to an absolute path and removing nested './'s.
1325 ///
1326 /// \return \c true if the path was changed.
1327 static bool cleanPathForOutput(FileManager &FileMgr,
1328  SmallVectorImpl<char> &Path) {
1329  bool Changed = FileMgr.makeAbsolutePath(Path);
1330  return Changed | llvm::sys::path::remove_dots(Path);
1331 }
1332 
1333 /// Adjusts the given filename to only write out the portion of the
1334 /// filename that is not part of the system root directory.
1335 ///
1336 /// \param Filename the file name to adjust.
1337 ///
1338 /// \param BaseDir When non-NULL, the PCH file is a relocatable AST file and
1339 /// the returned filename will be adjusted by this root directory.
1340 ///
1341 /// \returns either the original filename (if it needs no adjustment) or the
1342 /// adjusted filename (which points into the @p Filename parameter).
1343 static const char *
1344 adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir) {
1345  assert(Filename && "No file name to adjust?");
1346 
1347  if (BaseDir.empty())
1348  return Filename;
1349 
1350  // Verify that the filename and the system root have the same prefix.
1351  unsigned Pos = 0;
1352  for (; Filename[Pos] && Pos < BaseDir.size(); ++Pos)
1353  if (Filename[Pos] != BaseDir[Pos])
1354  return Filename; // Prefixes don't match.
1355 
1356  // We hit the end of the filename before we hit the end of the system root.
1357  if (!Filename[Pos])
1358  return Filename;
1359 
1360  // If there's not a path separator at the end of the base directory nor
1361  // immediately after it, then this isn't within the base directory.
1362  if (!llvm::sys::path::is_separator(Filename[Pos])) {
1363  if (!llvm::sys::path::is_separator(BaseDir.back()))
1364  return Filename;
1365  } else {
1366  // If the file name has a '/' at the current position, skip over the '/'.
1367  // We distinguish relative paths from absolute paths by the
1368  // absence of '/' at the beginning of relative paths.
1369  //
1370  // FIXME: This is wrong. We distinguish them by asking if the path is
1371  // absolute, which isn't the same thing. And there might be multiple '/'s
1372  // in a row. Use a better mechanism to indicate whether we have emitted an
1373  // absolute or relative path.
1374  ++Pos;
1375  }
1376 
1377  return Filename + Pos;
1378 }
1379 
1380 ASTFileSignature ASTWriter::createSignature(StringRef Bytes) {
1381  // Calculate the hash till start of UNHASHED_CONTROL_BLOCK.
1382  llvm::SHA1 Hasher;
1383  Hasher.update(ArrayRef<uint8_t>(Bytes.bytes_begin(), Bytes.size()));
1384  auto Hash = Hasher.result();
1385 
1386  // Convert to an array [5*i32].
1387  ASTFileSignature Signature;
1388  auto LShift = [&](unsigned char Val, unsigned Shift) {
1389  return (uint32_t)Val << Shift;
1390  };
1391  for (int I = 0; I != 5; ++I)
1392  Signature[I] = LShift(Hash[I * 4 + 0], 24) | LShift(Hash[I * 4 + 1], 16) |
1393  LShift(Hash[I * 4 + 2], 8) | LShift(Hash[I * 4 + 3], 0);
1394 
1395  return Signature;
1396 }
1397 
1398 ASTFileSignature ASTWriter::writeUnhashedControlBlock(Preprocessor &PP,
1399  ASTContext &Context) {
1400  // Flush first to prepare the PCM hash (signature).
1401  Stream.FlushToWord();
1402  auto StartOfUnhashedControl = Stream.GetCurrentBitNo() >> 3;
1403 
1404  // Enter the block and prepare to write records.
1405  RecordData Record;
1406  Stream.EnterSubblock(UNHASHED_CONTROL_BLOCK_ID, 5);
1407 
1408  // For implicit modules, write the hash of the PCM as its signature.
1409  ASTFileSignature Signature;
1410  if (WritingModule &&
1412  Signature = createSignature(StringRef(Buffer.begin(), StartOfUnhashedControl));
1413  Record.append(Signature.begin(), Signature.end());
1414  Stream.EmitRecord(SIGNATURE, Record);
1415  Record.clear();
1416  }
1417 
1418  // Diagnostic options.
1419  const auto &Diags = Context.getDiagnostics();
1420  const DiagnosticOptions &DiagOpts = Diags.getDiagnosticOptions();
1421 #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1422 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1423  Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1424 #include "clang/Basic/DiagnosticOptions.def"
1425  Record.push_back(DiagOpts.Warnings.size());
1426  for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I)
1427  AddString(DiagOpts.Warnings[I], Record);
1428  Record.push_back(DiagOpts.Remarks.size());
1429  for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I)
1430  AddString(DiagOpts.Remarks[I], Record);
1431  // Note: we don't serialize the log or serialization file names, because they
1432  // are generally transient files and will almost always be overridden.
1433  Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record);
1434 
1435  // Write out the diagnostic/pragma mappings.
1436  WritePragmaDiagnosticMappings(Diags, /* IsModule = */ WritingModule);
1437 
1438  // Leave the options block.
1439  Stream.ExitBlock();
1440  return Signature;
1441 }
1442 
1443 /// Write the control block.
1444 void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context,
1445  StringRef isysroot,
1446  const std::string &OutputFile) {
1447  using namespace llvm;
1448 
1449  Stream.EnterSubblock(CONTROL_BLOCK_ID, 5);
1450  RecordData Record;
1451 
1452  // Metadata
1453  auto MetadataAbbrev = std::make_shared<BitCodeAbbrev>();
1454  MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA));
1455  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major
1456  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor
1457  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj.
1458  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min.
1459  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
1460  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Timestamps
1461  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors
1462  MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
1463  unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));
1464  assert((!WritingModule || isysroot.empty()) &&
1465  "writing module as a relocatable PCH?");
1466  {
1467  RecordData::value_type Record[] = {METADATA, VERSION_MAJOR, VERSION_MINOR,
1468  CLANG_VERSION_MAJOR, CLANG_VERSION_MINOR,
1469  !isysroot.empty(), IncludeTimestamps,
1470  ASTHasCompilerErrors};
1471  Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record,
1473  }
1474 
1475  if (WritingModule) {
1476  // Module name
1477  auto Abbrev = std::make_shared<BitCodeAbbrev>();
1478  Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME));
1479  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
1480  unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1481  RecordData::value_type Record[] = {MODULE_NAME};
1482  Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name);
1483  }
1484 
1485  if (WritingModule && WritingModule->Directory) {
1486  SmallString<128> BaseDir(WritingModule->Directory->getName());
1487  cleanPathForOutput(Context.getSourceManager().getFileManager(), BaseDir);
1488 
1489  // If the home of the module is the current working directory, then we
1490  // want to pick up the cwd of the build process loading the module, not
1491  // our cwd, when we load this module.
1492  if (!PP.getHeaderSearchInfo()
1495  WritingModule->Directory->getName() != StringRef(".")) {
1496  // Module directory.
1497  auto Abbrev = std::make_shared<BitCodeAbbrev>();
1498  Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY));
1499  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory
1500  unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1501 
1502  RecordData::value_type Record[] = {MODULE_DIRECTORY};
1503  Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir);
1504  }
1505 
1506  // Write out all other paths relative to the base directory if possible.
1507  BaseDirectory.assign(BaseDir.begin(), BaseDir.end());
1508  } else if (!isysroot.empty()) {
1509  // Write out paths relative to the sysroot if possible.
1510  BaseDirectory = isysroot;
1511  }
1512 
1513  // Module map file
1514  if (WritingModule && WritingModule->Kind == Module::ModuleMapModule) {
1515  Record.clear();
1516 
1517  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
1518  AddPath(WritingModule->PresumedModuleMapFile.empty()
1519  ? Map.getModuleMapFileForUniquing(WritingModule)->getName()
1520  : StringRef(WritingModule->PresumedModuleMapFile),
1521  Record);
1522 
1523  // Additional module map files.
1524  if (auto *AdditionalModMaps =
1525  Map.getAdditionalModuleMapFiles(WritingModule)) {
1526  Record.push_back(AdditionalModMaps->size());
1527  for (const FileEntry *F : *AdditionalModMaps)
1528  AddPath(F->getName(), Record);
1529  } else {
1530  Record.push_back(0);
1531  }
1532 
1533  Stream.EmitRecord(MODULE_MAP_FILE, Record);
1534  }
1535 
1536  // Imports
1537  if (Chain) {
1538  serialization::ModuleManager &Mgr = Chain->getModuleManager();
1539  Record.clear();
1540 
1541  for (ModuleFile &M : Mgr) {
1542  // Skip modules that weren't directly imported.
1543  if (!M.isDirectlyImported())
1544  continue;
1545 
1546  Record.push_back((unsigned)M.Kind); // FIXME: Stable encoding
1547  AddSourceLocation(M.ImportLoc, Record);
1548 
1549  // If we have calculated signature, there is no need to store
1550  // the size or timestamp.
1551  Record.push_back(M.Signature ? 0 : M.File->getSize());
1552  Record.push_back(M.Signature ? 0 : getTimestampForOutput(M.File));
1553 
1554  for (auto I : M.Signature)
1555  Record.push_back(I);
1556 
1557  AddString(M.ModuleName, Record);
1558  AddPath(M.FileName, Record);
1559  }
1560  Stream.EmitRecord(IMPORTS, Record);
1561  }
1562 
1563  // Write the options block.
1564  Stream.EnterSubblock(OPTIONS_BLOCK_ID, 4);
1565 
1566  // Language options.
1567  Record.clear();
1568  const LangOptions &LangOpts = Context.getLangOpts();
1569 #define LANGOPT(Name, Bits, Default, Description) \
1570  Record.push_back(LangOpts.Name);
1571 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1572  Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1573 #include "clang/Basic/LangOptions.def"
1574 #define SANITIZER(NAME, ID) \
1575  Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID));
1576 #include "clang/Basic/Sanitizers.def"
1577 
1578  Record.push_back(LangOpts.ModuleFeatures.size());
1579  for (StringRef Feature : LangOpts.ModuleFeatures)
1580  AddString(Feature, Record);
1581 
1582  Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind());
1583  AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record);
1584 
1585  AddString(LangOpts.CurrentModule, Record);
1586 
1587  // Comment options.
1588  Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size());
1589  for (const auto &I : LangOpts.CommentOpts.BlockCommandNames) {
1590  AddString(I, Record);
1591  }
1592  Record.push_back(LangOpts.CommentOpts.ParseAllComments);
1593 
1594  // OpenMP offloading options.
1595  Record.push_back(LangOpts.OMPTargetTriples.size());
1596  for (auto &T : LangOpts.OMPTargetTriples)
1597  AddString(T.getTriple(), Record);
1598 
1599  AddString(LangOpts.OMPHostIRFile, Record);
1600 
1601  Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
1602 
1603  // Target options.
1604  Record.clear();
1605  const TargetInfo &Target = Context.getTargetInfo();
1606  const TargetOptions &TargetOpts = Target.getTargetOpts();
1607  AddString(TargetOpts.Triple, Record);
1608  AddString(TargetOpts.CPU, Record);
1609  AddString(TargetOpts.ABI, Record);
1610  Record.push_back(TargetOpts.FeaturesAsWritten.size());
1611  for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) {
1612  AddString(TargetOpts.FeaturesAsWritten[I], Record);
1613  }
1614  Record.push_back(TargetOpts.Features.size());
1615  for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) {
1616  AddString(TargetOpts.Features[I], Record);
1617  }
1618  Stream.EmitRecord(TARGET_OPTIONS, Record);
1619 
1620  // File system options.
1621  Record.clear();
1622  const FileSystemOptions &FSOpts =
1624  AddString(FSOpts.WorkingDir, Record);
1625  Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record);
1626 
1627  // Header search options.
1628  Record.clear();
1629  const HeaderSearchOptions &HSOpts
1631  AddString(HSOpts.Sysroot, Record);
1632 
1633  // Include entries.
1634  Record.push_back(HSOpts.UserEntries.size());
1635  for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
1636  const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I];
1637  AddString(Entry.Path, Record);
1638  Record.push_back(static_cast<unsigned>(Entry.Group));
1639  Record.push_back(Entry.IsFramework);
1640  Record.push_back(Entry.IgnoreSysRoot);
1641  }
1642 
1643  // System header prefixes.
1644  Record.push_back(HSOpts.SystemHeaderPrefixes.size());
1645  for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
1646  AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record);
1647  Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
1648  }
1649 
1650  AddString(HSOpts.ResourceDir, Record);
1651  AddString(HSOpts.ModuleCachePath, Record);
1652  AddString(HSOpts.ModuleUserBuildPath, Record);
1653  Record.push_back(HSOpts.DisableModuleHash);
1654  Record.push_back(HSOpts.ImplicitModuleMaps);
1655  Record.push_back(HSOpts.ModuleMapFileHomeIsCwd);
1656  Record.push_back(HSOpts.UseBuiltinIncludes);
1657  Record.push_back(HSOpts.UseStandardSystemIncludes);
1658  Record.push_back(HSOpts.UseStandardCXXIncludes);
1659  Record.push_back(HSOpts.UseLibcxx);
1660  // Write out the specific module cache path that contains the module files.
1661  AddString(PP.getHeaderSearchInfo().getModuleCachePath(), Record);
1662  Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record);
1663 
1664  // Preprocessor options.
1665  Record.clear();
1666  const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts();
1667 
1668  // Macro definitions.
1669  Record.push_back(PPOpts.Macros.size());
1670  for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
1671  AddString(PPOpts.Macros[I].first, Record);
1672  Record.push_back(PPOpts.Macros[I].second);
1673  }
1674 
1675  // Includes
1676  Record.push_back(PPOpts.Includes.size());
1677  for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I)
1678  AddString(PPOpts.Includes[I], Record);
1679 
1680  // Macro includes
1681  Record.push_back(PPOpts.MacroIncludes.size());
1682  for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I)
1683  AddString(PPOpts.MacroIncludes[I], Record);
1684 
1685  Record.push_back(PPOpts.UsePredefines);
1686  // Detailed record is important since it is used for the module cache hash.
1687  Record.push_back(PPOpts.DetailedRecord);
1688  AddString(PPOpts.ImplicitPCHInclude, Record);
1689  AddString(PPOpts.ImplicitPTHInclude, Record);
1690  Record.push_back(static_cast<unsigned>(PPOpts.ObjCXXARCStandardLibrary));
1691  Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record);
1692 
1693  // Leave the options block.
1694  Stream.ExitBlock();
1695 
1696  // Original file name and file ID
1697  SourceManager &SM = Context.getSourceManager();
1698  if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1699  auto FileAbbrev = std::make_shared<BitCodeAbbrev>();
1700  FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE));
1701  FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID
1702  FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1703  unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));
1704 
1705  Record.clear();
1706  Record.push_back(ORIGINAL_FILE);
1707  Record.push_back(SM.getMainFileID().getOpaqueValue());
1708  EmitRecordWithPath(FileAbbrevCode, Record, MainFile->getName());
1709  }
1710 
1711  Record.clear();
1712  Record.push_back(SM.getMainFileID().getOpaqueValue());
1713  Stream.EmitRecord(ORIGINAL_FILE_ID, Record);
1714 
1715  // Original PCH directory
1716  if (!OutputFile.empty() && OutputFile != "-") {
1717  auto Abbrev = std::make_shared<BitCodeAbbrev>();
1718  Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR));
1719  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1720  unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1721 
1722  SmallString<128> OutputPath(OutputFile);
1723 
1724  SM.getFileManager().makeAbsolutePath(OutputPath);
1725  StringRef origDir = llvm::sys::path::parent_path(OutputPath);
1726 
1727  RecordData::value_type Record[] = {ORIGINAL_PCH_DIR};
1728  Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
1729  }
1730 
1731  WriteInputFiles(Context.SourceMgr,
1733  PP.getLangOpts().Modules);
1734  Stream.ExitBlock();
1735 }
1736 
1737 namespace {
1738 
1739 /// An input file.
1740 struct InputFileEntry {
1741  const FileEntry *File;
1742  bool IsSystemFile;
1743  bool IsTransient;
1744  bool BufferOverridden;
1745  bool IsTopLevelModuleMap;
1746 };
1747 
1748 } // namespace
1749 
1750 void ASTWriter::WriteInputFiles(SourceManager &SourceMgr,
1751  HeaderSearchOptions &HSOpts,
1752  bool Modules) {
1753  using namespace llvm;
1754 
1755  Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4);
1756 
1757  // Create input-file abbreviation.
1758  auto IFAbbrev = std::make_shared<BitCodeAbbrev>();
1759  IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE));
1760  IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
1761  IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
1762  IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
1763  IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden
1764  IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Transient
1765  IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Module map
1766  IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1767  unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));
1768 
1769  // Get all ContentCache objects for files, sorted by whether the file is a
1770  // system one or not. System files go at the back, users files at the front.
1771  std::deque<InputFileEntry> SortedFiles;
1772  for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) {
1773  // Get this source location entry.
1774  const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
1775  assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc);
1776 
1777  // We only care about file entries that were not overridden.
1778  if (!SLoc->isFile())
1779  continue;
1780  const SrcMgr::FileInfo &File = SLoc->getFile();
1781  const SrcMgr::ContentCache *Cache = File.getContentCache();
1782  if (!Cache->OrigEntry)
1783  continue;
1784 
1785  InputFileEntry Entry;
1786  Entry.File = Cache->OrigEntry;
1787  Entry.IsSystemFile = Cache->IsSystemFile;
1788  Entry.IsTransient = Cache->IsTransient;
1789  Entry.BufferOverridden = Cache->BufferOverridden;
1790  Entry.IsTopLevelModuleMap = isModuleMap(File.getFileCharacteristic()) &&
1791  File.getIncludeLoc().isInvalid();
1792  if (Cache->IsSystemFile)
1793  SortedFiles.push_back(Entry);
1794  else
1795  SortedFiles.push_front(Entry);
1796  }
1797 
1798  unsigned UserFilesNum = 0;
1799  // Write out all of the input files.
1800  std::vector<uint64_t> InputFileOffsets;
1801  for (const auto &Entry : SortedFiles) {
1802  uint32_t &InputFileID = InputFileIDs[Entry.File];
1803  if (InputFileID != 0)
1804  continue; // already recorded this file.
1805 
1806  // Record this entry's offset.
1807  InputFileOffsets.push_back(Stream.GetCurrentBitNo());
1808 
1809  InputFileID = InputFileOffsets.size();
1810 
1811  if (!Entry.IsSystemFile)
1812  ++UserFilesNum;
1813 
1814  // Emit size/modification time for this file.
1815  // And whether this file was overridden.
1816  RecordData::value_type Record[] = {
1817  INPUT_FILE,
1818  InputFileOffsets.size(),
1819  (uint64_t)Entry.File->getSize(),
1820  (uint64_t)getTimestampForOutput(Entry.File),
1821  Entry.BufferOverridden,
1822  Entry.IsTransient,
1823  Entry.IsTopLevelModuleMap};
1824 
1825  EmitRecordWithPath(IFAbbrevCode, Record, Entry.File->getName());
1826  }
1827 
1828  Stream.ExitBlock();
1829 
1830  // Create input file offsets abbreviation.
1831  auto OffsetsAbbrev = std::make_shared<BitCodeAbbrev>();
1832  OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS));
1833  OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files
1834  OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system
1835  // input files
1836  OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array
1837  unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));
1838 
1839  // Write input file offsets.
1840  RecordData::value_type Record[] = {INPUT_FILE_OFFSETS,
1841  InputFileOffsets.size(), UserFilesNum};
1842  Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, bytes(InputFileOffsets));
1843 }
1844 
1845 //===----------------------------------------------------------------------===//
1846 // Source Manager Serialization
1847 //===----------------------------------------------------------------------===//
1848 
1849 /// Create an abbreviation for the SLocEntry that refers to a
1850 /// file.
1851 static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
1852  using namespace llvm;
1853 
1854  auto Abbrev = std::make_shared<BitCodeAbbrev>();
1855  Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
1856  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1857  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1858  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Characteristic
1859  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1860  // FileEntry fields.
1861  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID
1862  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs
1863  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex
1864  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls
1865  return Stream.EmitAbbrev(std::move(Abbrev));
1866 }
1867 
1868 /// Create an abbreviation for the SLocEntry that refers to a
1869 /// buffer.
1870 static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
1871  using namespace llvm;
1872 
1873  auto Abbrev = std::make_shared<BitCodeAbbrev>();
1874  Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
1875  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1876  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1877  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Characteristic
1878  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1879  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
1880  return Stream.EmitAbbrev(std::move(Abbrev));
1881 }
1882 
1883 /// Create an abbreviation for the SLocEntry that refers to a
1884 /// buffer's blob.
1885 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream,
1886  bool Compressed) {
1887  using namespace llvm;
1888 
1889  auto Abbrev = std::make_shared<BitCodeAbbrev>();
1890  Abbrev->Add(BitCodeAbbrevOp(Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED
1891  : SM_SLOC_BUFFER_BLOB));
1892  if (Compressed)
1893  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Uncompressed size
1894  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
1895  return Stream.EmitAbbrev(std::move(Abbrev));
1896 }
1897 
1898 /// Create an abbreviation for the SLocEntry that refers to a macro
1899 /// expansion.
1900 static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) {
1901  using namespace llvm;
1902 
1903  auto Abbrev = std::make_shared<BitCodeAbbrev>();
1904  Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY));
1905  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1906  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
1907  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
1908  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
1909  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is token range
1910  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
1911  return Stream.EmitAbbrev(std::move(Abbrev));
1912 }
1913 
1914 namespace {
1915 
1916  // Trait used for the on-disk hash table of header search information.
1917  class HeaderFileInfoTrait {
1918  ASTWriter &Writer;
1919 
1920  // Keep track of the framework names we've used during serialization.
1921  SmallVector<char, 128> FrameworkStringData;
1922  llvm::StringMap<unsigned> FrameworkNameOffset;
1923 
1924  public:
1925  HeaderFileInfoTrait(ASTWriter &Writer) : Writer(Writer) {}
1926 
1927  struct key_type {
1928  StringRef Filename;
1929  off_t Size;
1930  time_t ModTime;
1931  };
1932  using key_type_ref = const key_type &;
1933 
1934  using UnresolvedModule =
1935  llvm::PointerIntPair<Module *, 2, ModuleMap::ModuleHeaderRole>;
1936 
1937  struct data_type {
1938  const HeaderFileInfo &HFI;
1939  ArrayRef<ModuleMap::KnownHeader> KnownHeaders;
1940  UnresolvedModule Unresolved;
1941  };
1942  using data_type_ref = const data_type &;
1943 
1944  using hash_value_type = unsigned;
1945  using offset_type = unsigned;
1946 
1947  hash_value_type ComputeHash(key_type_ref key) {
1948  // The hash is based only on size/time of the file, so that the reader can
1949  // match even when symlinking or excess path elements ("foo/../", "../")
1950  // change the form of the name. However, complete path is still the key.
1951  return llvm::hash_combine(key.Size, key.ModTime);
1952  }
1953 
1954  std::pair<unsigned, unsigned>
1955  EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) {
1956  using namespace llvm::support;
1957 
1958  endian::Writer LE(Out, little);
1959  unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
1960  LE.write<uint16_t>(KeyLen);
1961  unsigned DataLen = 1 + 2 + 4 + 4;
1962  for (auto ModInfo : Data.KnownHeaders)
1963  if (Writer.getLocalOrImportedSubmoduleID(ModInfo.getModule()))
1964  DataLen += 4;
1965  if (Data.Unresolved.getPointer())
1966  DataLen += 4;
1967  LE.write<uint8_t>(DataLen);
1968  return std::make_pair(KeyLen, DataLen);
1969  }
1970 
1971  void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) {
1972  using namespace llvm::support;
1973 
1974  endian::Writer LE(Out, little);
1975  LE.write<uint64_t>(key.Size);
1976  KeyLen -= 8;
1977  LE.write<uint64_t>(key.ModTime);
1978  KeyLen -= 8;
1979  Out.write(key.Filename.data(), KeyLen);
1980  }
1981 
1982  void EmitData(raw_ostream &Out, key_type_ref key,
1983  data_type_ref Data, unsigned DataLen) {
1984  using namespace llvm::support;
1985 
1986  endian::Writer LE(Out, little);
1987  uint64_t Start = Out.tell(); (void)Start;
1988 
1989  unsigned char Flags = (Data.HFI.isImport << 5)
1990  | (Data.HFI.isPragmaOnce << 4)
1991  | (Data.HFI.DirInfo << 1)
1992  | Data.HFI.IndexHeaderMapHeader;
1993  LE.write<uint8_t>(Flags);
1994  LE.write<uint16_t>(Data.HFI.NumIncludes);
1995 
1996  if (!Data.HFI.ControllingMacro)
1997  LE.write<uint32_t>(Data.HFI.ControllingMacroID);
1998  else
1999  LE.write<uint32_t>(Writer.getIdentifierRef(Data.HFI.ControllingMacro));
2000 
2001  unsigned Offset = 0;
2002  if (!Data.HFI.Framework.empty()) {
2003  // If this header refers into a framework, save the framework name.
2004  llvm::StringMap<unsigned>::iterator Pos
2005  = FrameworkNameOffset.find(Data.HFI.Framework);
2006  if (Pos == FrameworkNameOffset.end()) {
2007  Offset = FrameworkStringData.size() + 1;
2008  FrameworkStringData.append(Data.HFI.Framework.begin(),
2009  Data.HFI.Framework.end());
2010  FrameworkStringData.push_back(0);
2011 
2012  FrameworkNameOffset[Data.HFI.Framework] = Offset;
2013  } else
2014  Offset = Pos->second;
2015  }
2016  LE.write<uint32_t>(Offset);
2017 
2018  auto EmitModule = [&](Module *M, ModuleMap::ModuleHeaderRole Role) {
2019  if (uint32_t ModID = Writer.getLocalOrImportedSubmoduleID(M)) {
2020  uint32_t Value = (ModID << 2) | (unsigned)Role;
2021  assert((Value >> 2) == ModID && "overflow in header module info");
2022  LE.write<uint32_t>(Value);
2023  }
2024  };
2025 
2026  // FIXME: If the header is excluded, we should write out some
2027  // record of that fact.
2028  for (auto ModInfo : Data.KnownHeaders)
2029  EmitModule(ModInfo.getModule(), ModInfo.getRole());
2030  if (Data.Unresolved.getPointer())
2031  EmitModule(Data.Unresolved.getPointer(), Data.Unresolved.getInt());
2032 
2033  assert(Out.tell() - Start == DataLen && "Wrong data length");
2034  }
2035 
2036  const char *strings_begin() const { return FrameworkStringData.begin(); }
2037  const char *strings_end() const { return FrameworkStringData.end(); }
2038  };
2039 
2040 } // namespace
2041 
2042 /// Write the header search block for the list of files that
2043 ///
2044 /// \param HS The header search structure to save.
2045 void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) {
2046  HeaderFileInfoTrait GeneratorTrait(*this);
2047  llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;
2048  SmallVector<const char *, 4> SavedStrings;
2049  unsigned NumHeaderSearchEntries = 0;
2050 
2051  // Find all unresolved headers for the current module. We generally will
2052  // have resolved them before we get here, but not necessarily: we might be
2053  // compiling a preprocessed module, where there is no requirement for the
2054  // original files to exist any more.
2055  const HeaderFileInfo Empty; // So we can take a reference.
2056  if (WritingModule) {
2057  llvm::SmallVector<Module *, 16> Worklist(1, WritingModule);
2058  while (!Worklist.empty()) {
2059  Module *M = Worklist.pop_back_val();
2060  if (!M->isAvailable())
2061  continue;
2062 
2063  // Map to disk files where possible, to pick up any missing stat
2064  // information. This also means we don't need to check the unresolved
2065  // headers list when emitting resolved headers in the first loop below.
2066  // FIXME: It'd be preferable to avoid doing this if we were given
2067  // sufficient stat information in the module map.
2069 
2070  // If the file didn't exist, we can still create a module if we were given
2071  // enough information in the module map.
2072  for (auto U : M->MissingHeaders) {
2073  // Check that we were given enough information to build a module
2074  // without this file existing on disk.
2075  if (!U.Size || (!U.ModTime && IncludeTimestamps)) {
2076  PP->Diag(U.FileNameLoc, diag::err_module_no_size_mtime_for_header)
2077  << WritingModule->getFullModuleName() << U.Size.hasValue()
2078  << U.FileName;
2079  continue;
2080  }
2081 
2082  // Form the effective relative pathname for the file.
2084  llvm::sys::path::append(Filename, U.FileName);
2085  PreparePathForOutput(Filename);
2086 
2087  StringRef FilenameDup = strdup(Filename.c_str());
2088  SavedStrings.push_back(FilenameDup.data());
2089 
2090  HeaderFileInfoTrait::key_type Key = {
2091  FilenameDup, *U.Size, IncludeTimestamps ? *U.ModTime : 0
2092  };
2093  HeaderFileInfoTrait::data_type Data = {
2094  Empty, {}, {M, ModuleMap::headerKindToRole(U.Kind)}
2095  };
2096  // FIXME: Deal with cases where there are multiple unresolved header
2097  // directives in different submodules for the same header.
2098  Generator.insert(Key, Data, GeneratorTrait);
2099  ++NumHeaderSearchEntries;
2100  }
2101 
2102  Worklist.append(M->submodule_begin(), M->submodule_end());
2103  }
2104  }
2105 
2107  HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
2108 
2109  if (FilesByUID.size() > HS.header_file_size())
2110  FilesByUID.resize(HS.header_file_size());
2111 
2112  for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
2113  const FileEntry *File = FilesByUID[UID];
2114  if (!File)
2115  continue;
2116 
2117  // Get the file info. This will load info from the external source if
2118  // necessary. Skip emitting this file if we have no information on it
2119  // as a header file (in which case HFI will be null) or if it hasn't
2120  // changed since it was loaded. Also skip it if it's for a modular header
2121  // from a different module; in that case, we rely on the module(s)
2122  // containing the header to provide this information.
2123  const HeaderFileInfo *HFI =
2124  HS.getExistingFileInfo(File, /*WantExternal*/!Chain);
2125  if (!HFI || (HFI->isModuleHeader && !HFI->isCompilingModuleHeader))
2126  continue;
2127 
2128  // Massage the file path into an appropriate form.
2129  StringRef Filename = File->getName();
2130  SmallString<128> FilenameTmp(Filename);
2131  if (PreparePathForOutput(FilenameTmp)) {
2132  // If we performed any translation on the file name at all, we need to
2133  // save this string, since the generator will refer to it later.
2134  Filename = StringRef(strdup(FilenameTmp.c_str()));
2135  SavedStrings.push_back(Filename.data());
2136  }
2137 
2138  HeaderFileInfoTrait::key_type Key = {
2139  Filename, File->getSize(), getTimestampForOutput(File)
2140  };
2141  HeaderFileInfoTrait::data_type Data = {
2142  *HFI, HS.getModuleMap().findAllModulesForHeader(File), {}
2143  };
2144  Generator.insert(Key, Data, GeneratorTrait);
2145  ++NumHeaderSearchEntries;
2146  }
2147 
2148  // Create the on-disk hash table in a buffer.
2149  SmallString<4096> TableData;
2150  uint32_t BucketOffset;
2151  {
2152  using namespace llvm::support;
2153 
2154  llvm::raw_svector_ostream Out(TableData);
2155  // Make sure that no bucket is at offset 0
2156  endian::write<uint32_t>(Out, 0, little);
2157  BucketOffset = Generator.Emit(Out, GeneratorTrait);
2158  }
2159 
2160  // Create a blob abbreviation
2161  using namespace llvm;
2162 
2163  auto Abbrev = std::make_shared<BitCodeAbbrev>();
2164  Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
2165  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2166  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2167  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2168  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2169  unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2170 
2171  // Write the header search table
2172  RecordData::value_type Record[] = {HEADER_SEARCH_TABLE, BucketOffset,
2173  NumHeaderSearchEntries, TableData.size()};
2174  TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
2175  Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData);
2176 
2177  // Free all of the strings we had to duplicate.
2178  for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
2179  free(const_cast<char *>(SavedStrings[I]));
2180 }
2181 
2182 static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
2183  unsigned SLocBufferBlobCompressedAbbrv,
2184  unsigned SLocBufferBlobAbbrv) {
2185  using RecordDataType = ASTWriter::RecordData::value_type;
2186 
2187  // Compress the buffer if possible. We expect that almost all PCM
2188  // consumers will not want its contents.
2189  SmallString<0> CompressedBuffer;
2190  if (llvm::zlib::isAvailable()) {
2191  llvm::Error E = llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer);
2192  if (!E) {
2193  RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED,
2194  Blob.size() - 1};
2195  Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record,
2196  CompressedBuffer);
2197  return;
2198  }
2199  llvm::consumeError(std::move(E));
2200  }
2201 
2202  RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB};
2203  Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob);
2204 }
2205 
2206 /// Writes the block containing the serialized form of the
2207 /// source manager.
2208 ///
2209 /// TODO: We should probably use an on-disk hash table (stored in a
2210 /// blob), indexed based on the file name, so that we only create
2211 /// entries for files that we actually need. In the common case (no
2212 /// errors), we probably won't have to create file entries for any of
2213 /// the files in the AST.
2214 void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
2215  const Preprocessor &PP) {
2216  RecordData Record;
2217 
2218  // Enter the source manager block.
2219  Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 4);
2220 
2221  // Abbreviations for the various kinds of source-location entries.
2222  unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
2223  unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
2224  unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false);
2225  unsigned SLocBufferBlobCompressedAbbrv =
2226  CreateSLocBufferBlobAbbrev(Stream, true);
2227  unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
2228 
2229  // Write out the source location entry table. We skip the first
2230  // entry, which is always the same dummy entry.
2231  std::vector<uint32_t> SLocEntryOffsets;
2232  RecordData PreloadSLocs;
2233  SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
2234  for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
2235  I != N; ++I) {
2236  // Get this source location entry.
2237  const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
2238  FileID FID = FileID::get(I);
2239  assert(&SourceMgr.getSLocEntry(FID) == SLoc);
2240 
2241  // Record the offset of this source-location entry.
2242  SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
2243 
2244  // Figure out which record code to use.
2245  unsigned Code;
2246  if (SLoc->isFile()) {
2248  if (Cache->OrigEntry) {
2249  Code = SM_SLOC_FILE_ENTRY;
2250  } else
2251  Code = SM_SLOC_BUFFER_ENTRY;
2252  } else
2253  Code = SM_SLOC_EXPANSION_ENTRY;
2254  Record.clear();
2255  Record.push_back(Code);
2256 
2257  // Starting offset of this entry within this module, so skip the dummy.
2258  Record.push_back(SLoc->getOffset() - 2);
2259  if (SLoc->isFile()) {
2260  const SrcMgr::FileInfo &File = SLoc->getFile();
2261  AddSourceLocation(File.getIncludeLoc(), Record);
2262  Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding
2263  Record.push_back(File.hasLineDirectives());
2264 
2265  const SrcMgr::ContentCache *Content = File.getContentCache();
2266  bool EmitBlob = false;
2267  if (Content->OrigEntry) {
2268  assert(Content->OrigEntry == Content->ContentsEntry &&
2269  "Writing to AST an overridden file is not supported");
2270 
2271  // The source location entry is a file. Emit input file ID.
2272  assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry");
2273  Record.push_back(InputFileIDs[Content->OrigEntry]);
2274 
2275  Record.push_back(File.NumCreatedFIDs);
2276 
2277  FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
2278  if (FDI != FileDeclIDs.end()) {
2279  Record.push_back(FDI->second->FirstDeclIndex);
2280  Record.push_back(FDI->second->DeclIDs.size());
2281  } else {
2282  Record.push_back(0);
2283  Record.push_back(0);
2284  }
2285 
2286  Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record);
2287 
2288  if (Content->BufferOverridden || Content->IsTransient)
2289  EmitBlob = true;
2290  } else {
2291  // The source location entry is a buffer. The blob associated
2292  // with this entry contains the contents of the buffer.
2293 
2294  // We add one to the size so that we capture the trailing NULL
2295  // that is required by llvm::MemoryBuffer::getMemBuffer (on
2296  // the reader side).
2297  const llvm::MemoryBuffer *Buffer
2298  = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
2299  StringRef Name = Buffer->getBufferIdentifier();
2300  Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
2301  StringRef(Name.data(), Name.size() + 1));
2302  EmitBlob = true;
2303 
2304  if (Name == "<built-in>")
2305  PreloadSLocs.push_back(SLocEntryOffsets.size());
2306  }
2307 
2308  if (EmitBlob) {
2309  // Include the implicit terminating null character in the on-disk buffer
2310  // if we're writing it uncompressed.
2311  const llvm::MemoryBuffer *Buffer =
2312  Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
2313  StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
2314  emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
2315  SLocBufferBlobAbbrv);
2316  }
2317  } else {
2318  // The source location entry is a macro expansion.
2319  const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
2320  AddSourceLocation(Expansion.getSpellingLoc(), Record);
2321  AddSourceLocation(Expansion.getExpansionLocStart(), Record);
2322  AddSourceLocation(Expansion.isMacroArgExpansion()
2323  ? SourceLocation()
2324  : Expansion.getExpansionLocEnd(),
2325  Record);
2326  Record.push_back(Expansion.isExpansionTokenRange());
2327 
2328  // Compute the token length for this macro expansion.
2329  unsigned NextOffset = SourceMgr.getNextLocalOffset();
2330  if (I + 1 != N)
2331  NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
2332  Record.push_back(NextOffset - SLoc->getOffset() - 1);
2333  Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
2334  }
2335  }
2336 
2337  Stream.ExitBlock();
2338 
2339  if (SLocEntryOffsets.empty())
2340  return;
2341 
2342  // Write the source-location offsets table into the AST block. This
2343  // table is used for lazily loading source-location information.
2344  using namespace llvm;
2345 
2346  auto Abbrev = std::make_shared<BitCodeAbbrev>();
2347  Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
2348  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
2349  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
2350  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
2351  unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2352  {
2353  RecordData::value_type Record[] = {
2354  SOURCE_LOCATION_OFFSETS, SLocEntryOffsets.size(),
2355  SourceMgr.getNextLocalOffset() - 1 /* skip dummy */};
2356  Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record,
2357  bytes(SLocEntryOffsets));
2358  }
2359  // Write the source location entry preloads array, telling the AST
2360  // reader which source locations entries it should load eagerly.
2361  Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
2362 
2363  // Write the line table. It depends on remapping working, so it must come
2364  // after the source location offsets.
2365  if (SourceMgr.hasLineTable()) {
2366  LineTableInfo &LineTable = SourceMgr.getLineTable();
2367 
2368  Record.clear();
2369 
2370  // Emit the needed file names.
2371  llvm::DenseMap<int, int> FilenameMap;
2372  FilenameMap[-1] = -1; // For unspecified filenames.
2373  for (const auto &L : LineTable) {
2374  if (L.first.ID < 0)
2375  continue;
2376  for (auto &LE : L.second) {
2377  if (FilenameMap.insert(std::make_pair(LE.FilenameID,
2378  FilenameMap.size() - 1)).second)
2379  AddPath(LineTable.getFilename(LE.FilenameID), Record);
2380  }
2381  }
2382  Record.push_back(0);
2383 
2384  // Emit the line entries
2385  for (const auto &L : LineTable) {
2386  // Only emit entries for local files.
2387  if (L.first.ID < 0)
2388  continue;
2389 
2390  // Emit the file ID
2391  Record.push_back(L.first.ID);
2392 
2393  // Emit the line entries
2394  Record.push_back(L.second.size());
2395  for (const auto &LE : L.second) {
2396  Record.push_back(LE.FileOffset);
2397  Record.push_back(LE.LineNo);
2398  Record.push_back(FilenameMap[LE.FilenameID]);
2399  Record.push_back((unsigned)LE.FileKind);
2400  Record.push_back(LE.IncludeOffset);
2401  }
2402  }
2403 
2404  Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record);
2405  }
2406 }
2407 
2408 //===----------------------------------------------------------------------===//
2409 // Preprocessor Serialization
2410 //===----------------------------------------------------------------------===//
2411 
2412 static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule,
2413  const Preprocessor &PP) {
2414  if (MacroInfo *MI = MD->getMacroInfo())
2415  if (MI->isBuiltinMacro())
2416  return true;
2417 
2418  if (IsModule) {
2419  SourceLocation Loc = MD->getLocation();
2420  if (Loc.isInvalid())
2421  return true;
2422  if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID())
2423  return true;
2424  }
2425 
2426  return false;
2427 }
2428 
2429 /// Writes the block containing the serialized form of the
2430 /// preprocessor.
2431 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
2433  if (PPRec)
2434  WritePreprocessorDetail(*PPRec);
2435 
2436  RecordData Record;
2437  RecordData ModuleMacroRecord;
2438 
2439  // If the preprocessor __COUNTER__ value has been bumped, remember it.
2440  if (PP.getCounterValue() != 0) {
2441  RecordData::value_type Record[] = {PP.getCounterValue()};
2442  Stream.EmitRecord(PP_COUNTER_VALUE, Record);
2443  }
2444 
2445  if (PP.isRecordingPreamble() && PP.hasRecordedPreamble()) {
2446  assert(!IsModule);
2447  auto SkipInfo = PP.getPreambleSkipInfo();
2448  if (SkipInfo.hasValue()) {
2449  Record.push_back(true);
2450  AddSourceLocation(SkipInfo->HashTokenLoc, Record);
2451  AddSourceLocation(SkipInfo->IfTokenLoc, Record);
2452  Record.push_back(SkipInfo->FoundNonSkipPortion);
2453  Record.push_back(SkipInfo->FoundElse);
2454  AddSourceLocation(SkipInfo->ElseLoc, Record);
2455  } else {
2456  Record.push_back(false);
2457  }
2458  for (const auto &Cond : PP.getPreambleConditionalStack()) {
2459  AddSourceLocation(Cond.IfLoc, Record);
2460  Record.push_back(Cond.WasSkipping);
2461  Record.push_back(Cond.FoundNonSkip);
2462  Record.push_back(Cond.FoundElse);
2463  }
2464  Stream.EmitRecord(PP_CONDITIONAL_STACK, Record);
2465  Record.clear();
2466  }
2467 
2468  // Enter the preprocessor block.
2469  Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3);
2470 
2471  // If the AST file contains __DATE__ or __TIME__ emit a warning about this.
2472  // FIXME: Include a location for the use, and say which one was used.
2473  if (PP.SawDateOrTime())
2474  PP.Diag(SourceLocation(), diag::warn_module_uses_date_time) << IsModule;
2475 
2476  // Loop over all the macro directives that are live at the end of the file,
2477  // emitting each to the PP section.
2478 
2479  // Construct the list of identifiers with macro directives that need to be
2480  // serialized.
2482  for (auto &Id : PP.getIdentifierTable())
2483  if (Id.second->hadMacroDefinition() &&
2484  (!Id.second->isFromAST() ||
2485  Id.second->hasChangedSinceDeserialization()))
2486  MacroIdentifiers.push_back(Id.second);
2487  // Sort the set of macro definitions that need to be serialized by the
2488  // name of the macro, to provide a stable ordering.
2489  llvm::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(),
2490  llvm::less_ptr<IdentifierInfo>());
2491 
2492  // Emit the macro directives as a list and associate the offset with the
2493  // identifier they belong to.
2494  for (const IdentifierInfo *Name : MacroIdentifiers) {
2496  auto StartOffset = Stream.GetCurrentBitNo();
2497 
2498  // Emit the macro directives in reverse source order.
2499  for (; MD; MD = MD->getPrevious()) {
2500  // Once we hit an ignored macro, we're done: the rest of the chain
2501  // will all be ignored macros.
2502  if (shouldIgnoreMacro(MD, IsModule, PP))
2503  break;
2504 
2505  AddSourceLocation(MD->getLocation(), Record);
2506  Record.push_back(MD->getKind());
2507  if (auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2508  Record.push_back(getMacroRef(DefMD->getInfo(), Name));
2509  } else if (auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2510  Record.push_back(VisMD->isPublic());
2511  }
2512  }
2513 
2514  // Write out any exported module macros.
2515  bool EmittedModuleMacros = false;
2516  // We write out exported module macros for PCH as well.
2517  auto Leafs = PP.getLeafModuleMacros(Name);
2518  SmallVector<ModuleMacro*, 8> Worklist(Leafs.begin(), Leafs.end());
2519  llvm::DenseMap<ModuleMacro*, unsigned> Visits;
2520  while (!Worklist.empty()) {
2521  auto *Macro = Worklist.pop_back_val();
2522 
2523  // Emit a record indicating this submodule exports this macro.
2524  ModuleMacroRecord.push_back(
2525  getSubmoduleID(Macro->getOwningModule()));
2526  ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name));
2527  for (auto *M : Macro->overrides())
2528  ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));
2529 
2530  Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord);
2531  ModuleMacroRecord.clear();
2532 
2533  // Enqueue overridden macros once we've visited all their ancestors.
2534  for (auto *M : Macro->overrides())
2535  if (++Visits[M] == M->getNumOverridingMacros())
2536  Worklist.push_back(M);
2537 
2538  EmittedModuleMacros = true;
2539  }
2540 
2541  if (Record.empty() && !EmittedModuleMacros)
2542  continue;
2543 
2544  IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2545  Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record);
2546  Record.clear();
2547  }
2548 
2549  /// Offsets of each of the macros into the bitstream, indexed by
2550  /// the local macro ID
2551  ///
2552  /// For each identifier that is associated with a macro, this map
2553  /// provides the offset into the bitstream where that macro is
2554  /// defined.
2555  std::vector<uint32_t> MacroOffsets;
2556 
2557  for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2558  const IdentifierInfo *Name = MacroInfosToEmit[I].Name;
2559  MacroInfo *MI = MacroInfosToEmit[I].MI;
2560  MacroID ID = MacroInfosToEmit[I].ID;
2561 
2562  if (ID < FirstMacroID) {
2563  assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?");
2564  continue;
2565  }
2566 
2567  // Record the local offset of this macro.
2568  unsigned Index = ID - FirstMacroID;
2569  if (Index == MacroOffsets.size())
2570  MacroOffsets.push_back(Stream.GetCurrentBitNo());
2571  else {
2572  if (Index > MacroOffsets.size())
2573  MacroOffsets.resize(Index + 1);
2574 
2575  MacroOffsets[Index] = Stream.GetCurrentBitNo();
2576  }
2577 
2578  AddIdentifierRef(Name, Record);
2579  AddSourceLocation(MI->getDefinitionLoc(), Record);
2580  AddSourceLocation(MI->getDefinitionEndLoc(), Record);
2581  Record.push_back(MI->isUsed());
2582  Record.push_back(MI->isUsedForHeaderGuard());
2583  unsigned Code;
2584  if (MI->isObjectLike()) {
2585  Code = PP_MACRO_OBJECT_LIKE;
2586  } else {
2587  Code = PP_MACRO_FUNCTION_LIKE;
2588 
2589  Record.push_back(MI->isC99Varargs());
2590  Record.push_back(MI->isGNUVarargs());
2591  Record.push_back(MI->hasCommaPasting());
2592  Record.push_back(MI->getNumParams());
2593  for (const IdentifierInfo *Param : MI->params())
2594  AddIdentifierRef(Param, Record);
2595  }
2596 
2597  // If we have a detailed preprocessing record, record the macro definition
2598  // ID that corresponds to this macro.
2599  if (PPRec)
2600  Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]);
2601 
2602  Stream.EmitRecord(Code, Record);
2603  Record.clear();
2604 
2605  // Emit the tokens array.
2606  for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) {
2607  // Note that we know that the preprocessor does not have any annotation
2608  // tokens in it because they are created by the parser, and thus can't
2609  // be in a macro definition.
2610  const Token &Tok = MI->getReplacementToken(TokNo);
2611  AddToken(Tok, Record);
2612  Stream.EmitRecord(PP_TOKEN, Record);
2613  Record.clear();
2614  }
2615  ++NumMacros;
2616  }
2617 
2618  Stream.ExitBlock();
2619 
2620  // Write the offsets table for macro IDs.
2621  using namespace llvm;
2622 
2623  auto Abbrev = std::make_shared<BitCodeAbbrev>();
2624  Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET));
2625  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros
2626  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
2627  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2628 
2629  unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2630  {
2631  RecordData::value_type Record[] = {MACRO_OFFSET, MacroOffsets.size(),
2632  FirstMacroID - NUM_PREDEF_MACRO_IDS};
2633  Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, bytes(MacroOffsets));
2634  }
2635 }
2636 
2637 void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
2638  if (PPRec.local_begin() == PPRec.local_end())
2639  return;
2640 
2641  SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
2642 
2643  // Enter the preprocessor block.
2644  Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3);
2645 
2646  // If the preprocessor has a preprocessing record, emit it.
2647  unsigned NumPreprocessingRecords = 0;
2648  using namespace llvm;
2649 
2650  // Set up the abbreviation for
2651  unsigned InclusionAbbrev = 0;
2652  {
2653  auto Abbrev = std::make_shared<BitCodeAbbrev>();
2654  Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE));
2655  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
2656  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
2657  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
2658  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module
2659  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2660  InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2661  }
2662 
2663  unsigned FirstPreprocessorEntityID
2664  = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2666  unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
2667  RecordData Record;
2668  for (PreprocessingRecord::iterator E = PPRec.local_begin(),
2669  EEnd = PPRec.local_end();
2670  E != EEnd;
2671  (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
2672  Record.clear();
2673 
2674  PreprocessedEntityOffsets.push_back(
2675  PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo()));
2676 
2677  if (auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) {
2678  // Record this macro definition's ID.
2679  MacroDefinitions[MD] = NextPreprocessorEntityID;
2680 
2681  AddIdentifierRef(MD->getName(), Record);
2682  Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
2683  continue;
2684  }
2685 
2686  if (auto *ME = dyn_cast<MacroExpansion>(*E)) {
2687  Record.push_back(ME->isBuiltinMacro());
2688  if (ME->isBuiltinMacro())
2689  AddIdentifierRef(ME->getName(), Record);
2690  else
2691  Record.push_back(MacroDefinitions[ME->getDefinition()]);
2692  Stream.EmitRecord(PPD_MACRO_EXPANSION, Record);
2693  continue;
2694  }
2695 
2696  if (auto *ID = dyn_cast<InclusionDirective>(*E)) {
2697  Record.push_back(PPD_INCLUSION_DIRECTIVE);
2698  Record.push_back(ID->getFileName().size());
2699  Record.push_back(ID->wasInQuotes());
2700  Record.push_back(static_cast<unsigned>(ID->getKind()));
2701  Record.push_back(ID->importedModule());
2702  SmallString<64> Buffer;
2703  Buffer += ID->getFileName();
2704  // Check that the FileEntry is not null because it was not resolved and
2705  // we create a PCH even with compiler errors.
2706  if (ID->getFile())
2707  Buffer += ID->getFile()->getName();
2708  Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer);
2709  continue;
2710  }
2711 
2712  llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter");
2713  }
2714  Stream.ExitBlock();
2715 
2716  // Write the offsets table for the preprocessing record.
2717  if (NumPreprocessingRecords > 0) {
2718  assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2719 
2720  // Write the offsets table for identifier IDs.
2721  using namespace llvm;
2722 
2723  auto Abbrev = std::make_shared<BitCodeAbbrev>();
2724  Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS));
2725  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity
2726  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2727  unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2728 
2729  RecordData::value_type Record[] = {PPD_ENTITIES_OFFSETS,
2730  FirstPreprocessorEntityID -
2732  Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record,
2733  bytes(PreprocessedEntityOffsets));
2734  }
2735 
2736  // Write the skipped region table for the preprocessing record.
2737  ArrayRef<SourceRange> SkippedRanges = PPRec.getSkippedRanges();
2738  if (SkippedRanges.size() > 0) {
2739  std::vector<PPSkippedRange> SerializedSkippedRanges;
2740  SerializedSkippedRanges.reserve(SkippedRanges.size());
2741  for (auto const& Range : SkippedRanges)
2742  SerializedSkippedRanges.emplace_back(Range);
2743 
2744  using namespace llvm;
2745  auto Abbrev = std::make_shared<BitCodeAbbrev>();
2746  Abbrev->Add(BitCodeAbbrevOp(PPD_SKIPPED_RANGES));
2747  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2748  unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2749 
2750  Record.clear();
2751  Record.push_back(PPD_SKIPPED_RANGES);
2752  Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev, Record,
2753  bytes(SerializedSkippedRanges));
2754  }
2755 }
2756 
2758  if (!Mod)
2759  return 0;
2760 
2761  llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod);
2762  if (Known != SubmoduleIDs.end())
2763  return Known->second;
2764 
2765  auto *Top = Mod->getTopLevelModule();
2766  if (Top != WritingModule &&
2767  (getLangOpts().CompilingPCH ||
2768  !Top->fullModuleNameIs(StringRef(getLangOpts().CurrentModule))))
2769  return 0;
2770 
2771  return SubmoduleIDs[Mod] = NextSubmoduleID++;
2772 }
2773 
2774 unsigned ASTWriter::getSubmoduleID(Module *Mod) {
2775  // FIXME: This can easily happen, if we have a reference to a submodule that
2776  // did not result in us loading a module file for that submodule. For
2777  // instance, a cross-top-level-module 'conflict' declaration will hit this.
2778  unsigned ID = getLocalOrImportedSubmoduleID(Mod);
2779  assert((ID || !Mod) &&
2780  "asked for module ID for non-local, non-imported module");
2781  return ID;
2782 }
2783 
2784 /// Compute the number of modules within the given tree (including the
2785 /// given module).
2786 static unsigned getNumberOfModules(Module *Mod) {
2787  unsigned ChildModules = 0;
2788  for (auto Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end();
2789  Sub != SubEnd; ++Sub)
2790  ChildModules += getNumberOfModules(*Sub);
2791 
2792  return ChildModules + 1;
2793 }
2794 
2795 void ASTWriter::WriteSubmodules(Module *WritingModule) {
2796  // Enter the submodule description block.
2797  Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/5);
2798 
2799  // Write the abbreviations needed for the submodules block.
2800  using namespace llvm;
2801 
2802  auto Abbrev = std::make_shared<BitCodeAbbrev>();
2803  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION));
2804  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
2805  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent
2806  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind
2807  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
2808  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit
2809  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem
2810  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC
2811  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules...
2812  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit...
2813  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild...
2814  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh...
2815  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModuleMapIsPriv...
2816  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2817  unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2818 
2819  Abbrev = std::make_shared<BitCodeAbbrev>();
2820  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER));
2821  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2822  unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2823 
2824  Abbrev = std::make_shared<BitCodeAbbrev>();
2825  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER));
2826  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2827  unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2828 
2829  Abbrev = std::make_shared<BitCodeAbbrev>();
2830  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER));
2831  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2832  unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2833 
2834  Abbrev = std::make_shared<BitCodeAbbrev>();
2835  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR));
2836  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2837  unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2838 
2839  Abbrev = std::make_shared<BitCodeAbbrev>();
2840  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES));
2841  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State
2842  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature
2843  unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2844 
2845  Abbrev = std::make_shared<BitCodeAbbrev>();
2846  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER));
2847  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2848  unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2849 
2850  Abbrev = std::make_shared<BitCodeAbbrev>();
2851  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TEXTUAL_HEADER));
2852  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2853  unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2854 
2855  Abbrev = std::make_shared<BitCodeAbbrev>();
2856  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER));
2857  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2858  unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2859 
2860  Abbrev = std::make_shared<BitCodeAbbrev>();
2861  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_TEXTUAL_HEADER));
2862  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2863  unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2864 
2865  Abbrev = std::make_shared<BitCodeAbbrev>();
2866  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY));
2867  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
2868  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2869  unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2870 
2871  Abbrev = std::make_shared<BitCodeAbbrev>();
2872  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO));
2873  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name
2874  unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2875 
2876  Abbrev = std::make_shared<BitCodeAbbrev>();
2877  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT));
2878  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module
2879  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message
2880  unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2881 
2882  Abbrev = std::make_shared<BitCodeAbbrev>();
2883  Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXPORT_AS));
2884  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name
2885  unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2886 
2887  // Write the submodule metadata block.
2888  RecordData::value_type Record[] = {
2889  getNumberOfModules(WritingModule),
2890  FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS};
2891  Stream.EmitRecord(SUBMODULE_METADATA, Record);
2892 
2893  // Write all of the submodules.
2894  std::queue<Module *> Q;
2895  Q.push(WritingModule);
2896  while (!Q.empty()) {
2897  Module *Mod = Q.front();
2898  Q.pop();
2899  unsigned ID = getSubmoduleID(Mod);
2900 
2901  uint64_t ParentID = 0;
2902  if (Mod->Parent) {
2903  assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?");
2904  ParentID = SubmoduleIDs[Mod->Parent];
2905  }
2906 
2907  // Emit the definition of the block.
2908  {
2909  RecordData::value_type Record[] = {SUBMODULE_DEFINITION,
2910  ID,
2911  ParentID,
2912  (RecordData::value_type)Mod->Kind,
2913  Mod->IsFramework,
2914  Mod->IsExplicit,
2915  Mod->IsSystem,
2916  Mod->IsExternC,
2917  Mod->InferSubmodules,
2919  Mod->InferExportWildcard,
2921  Mod->ModuleMapIsPrivate};
2922  Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name);
2923  }
2924 
2925  // Emit the requirements.
2926  for (const auto &R : Mod->Requirements) {
2927  RecordData::value_type Record[] = {SUBMODULE_REQUIRES, R.second};
2928  Stream.EmitRecordWithBlob(RequiresAbbrev, Record, R.first);
2929  }
2930 
2931  // Emit the umbrella header, if there is one.
2932  if (auto UmbrellaHeader = Mod->getUmbrellaHeader()) {
2933  RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_HEADER};
2934  Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record,
2935  UmbrellaHeader.NameAsWritten);
2936  } else if (auto UmbrellaDir = Mod->getUmbrellaDir()) {
2937  RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_DIR};
2938  Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record,
2939  UmbrellaDir.NameAsWritten);
2940  }
2941 
2942  // Emit the headers.
2943  struct {
2944  unsigned RecordKind;
2945  unsigned Abbrev;
2946  Module::HeaderKind HeaderKind;
2947  } HeaderLists[] = {
2948  {SUBMODULE_HEADER, HeaderAbbrev, Module::HK_Normal},
2949  {SUBMODULE_TEXTUAL_HEADER, TextualHeaderAbbrev, Module::HK_Textual},
2950  {SUBMODULE_PRIVATE_HEADER, PrivateHeaderAbbrev, Module::HK_Private},
2951  {SUBMODULE_PRIVATE_TEXTUAL_HEADER, PrivateTextualHeaderAbbrev,
2953  {SUBMODULE_EXCLUDED_HEADER, ExcludedHeaderAbbrev, Module::HK_Excluded}
2954  };
2955  for (auto &HL : HeaderLists) {
2956  RecordData::value_type Record[] = {HL.RecordKind};
2957  for (auto &H : Mod->Headers[HL.HeaderKind])
2958  Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten);
2959  }
2960 
2961  // Emit the top headers.
2962  {
2963  auto TopHeaders = Mod->getTopHeaders(PP->getFileManager());
2964  RecordData::value_type Record[] = {SUBMODULE_TOPHEADER};
2965  for (auto *H : TopHeaders)
2966  Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, H->getName());
2967  }
2968 
2969  // Emit the imports.
2970  if (!Mod->Imports.empty()) {
2971  RecordData Record;
2972  for (auto *I : Mod->Imports)
2973  Record.push_back(getSubmoduleID(I));
2974  Stream.EmitRecord(SUBMODULE_IMPORTS, Record);
2975  }
2976 
2977  // Emit the exports.
2978  if (!Mod->Exports.empty()) {
2979  RecordData Record;
2980  for (const auto &E : Mod->Exports) {
2981  // FIXME: This may fail; we don't require that all exported modules
2982  // are local or imported.
2983  Record.push_back(getSubmoduleID(E.getPointer()));
2984  Record.push_back(E.getInt());
2985  }
2986  Stream.EmitRecord(SUBMODULE_EXPORTS, Record);
2987  }
2988 
2989  //FIXME: How do we emit the 'use'd modules? They may not be submodules.
2990  // Might be unnecessary as use declarations are only used to build the
2991  // module itself.
2992 
2993  // Emit the link libraries.
2994  for (const auto &LL : Mod->LinkLibraries) {
2995  RecordData::value_type Record[] = {SUBMODULE_LINK_LIBRARY,
2996  LL.IsFramework};
2997  Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, LL.Library);
2998  }
2999 
3000  // Emit the conflicts.
3001  for (const auto &C : Mod->Conflicts) {
3002  // FIXME: This may fail; we don't require that all conflicting modules
3003  // are local or imported.
3004  RecordData::value_type Record[] = {SUBMODULE_CONFLICT,
3005  getSubmoduleID(C.Other)};
3006  Stream.EmitRecordWithBlob(ConflictAbbrev, Record, C.Message);
3007  }
3008 
3009  // Emit the configuration macros.
3010  for (const auto &CM : Mod->ConfigMacros) {
3011  RecordData::value_type Record[] = {SUBMODULE_CONFIG_MACRO};
3012  Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, CM);
3013  }
3014 
3015  // Emit the initializers, if any.
3016  RecordData Inits;
3017  for (Decl *D : Context->getModuleInitializers(Mod))
3018  Inits.push_back(GetDeclRef(D));
3019  if (!Inits.empty())
3020  Stream.EmitRecord(SUBMODULE_INITIALIZERS, Inits);
3021 
3022  // Emit the name of the re-exported module, if any.
3023  if (!Mod->ExportAsModule.empty()) {
3024  RecordData::value_type Record[] = {SUBMODULE_EXPORT_AS};
3025  Stream.EmitRecordWithBlob(ExportAsAbbrev, Record, Mod->ExportAsModule);
3026  }
3027 
3028  // Queue up the submodules of this module.
3029  for (auto *M : Mod->submodules())
3030  Q.push(M);
3031  }
3032 
3033  Stream.ExitBlock();
3034 
3035  assert((NextSubmoduleID - FirstSubmoduleID ==
3036  getNumberOfModules(WritingModule)) &&
3037  "Wrong # of submodules; found a reference to a non-local, "
3038  "non-imported submodule?");
3039 }
3040 
3041 void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag,
3042  bool isModule) {
3043  llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
3044  DiagStateIDMap;
3045  unsigned CurrID = 0;
3046  RecordData Record;
3047 
3048  auto EncodeDiagStateFlags =
3049  [](const DiagnosticsEngine::DiagState *DS) -> unsigned {
3050  unsigned Result = (unsigned)DS->ExtBehavior;
3051  for (unsigned Val :
3052  {(unsigned)DS->IgnoreAllWarnings, (unsigned)DS->EnableAllWarnings,
3053  (unsigned)DS->WarningsAsErrors, (unsigned)DS->ErrorsAsFatal,
3054  (unsigned)DS->SuppressSystemWarnings})
3055  Result = (Result << 1) | Val;
3056  return Result;
3057  };
3058 
3059  unsigned Flags = EncodeDiagStateFlags(Diag.DiagStatesByLoc.FirstDiagState);
3060  Record.push_back(Flags);
3061 
3062  auto AddDiagState = [&](const DiagnosticsEngine::DiagState *State,
3063  bool IncludeNonPragmaStates) {
3064  // Ensure that the diagnostic state wasn't modified since it was created.
3065  // We will not correctly round-trip this information otherwise.
3066  assert(Flags == EncodeDiagStateFlags(State) &&
3067  "diag state flags vary in single AST file");
3068 
3069  unsigned &DiagStateID = DiagStateIDMap[State];
3070  Record.push_back(DiagStateID);
3071 
3072  if (DiagStateID == 0) {
3073  DiagStateID = ++CurrID;
3074 
3075  // Add a placeholder for the number of mappings.
3076  auto SizeIdx = Record.size();
3077  Record.emplace_back();
3078  for (const auto &I : *State) {
3079  if (I.second.isPragma() || IncludeNonPragmaStates) {
3080  Record.push_back(I.first);
3081  Record.push_back(I.second.serialize());
3082  }
3083  }
3084  // Update the placeholder.
3085  Record[SizeIdx] = (Record.size() - SizeIdx) / 2;
3086  }
3087  };
3088 
3089  AddDiagState(Diag.DiagStatesByLoc.FirstDiagState, isModule);
3090 
3091  // Reserve a spot for the number of locations with state transitions.
3092  auto NumLocationsIdx = Record.size();
3093  Record.emplace_back();
3094 
3095  // Emit the state transitions.
3096  unsigned NumLocations = 0;
3097  for (auto &FileIDAndFile : Diag.DiagStatesByLoc.Files) {
3098  if (!FileIDAndFile.first.isValid() ||
3099  !FileIDAndFile.second.HasLocalTransitions)
3100  continue;
3101  ++NumLocations;
3102 
3103  SourceLocation Loc = Diag.SourceMgr->getComposedLoc(FileIDAndFile.first, 0);
3104  assert(!Loc.isInvalid() && "start loc for valid FileID is invalid");
3105  AddSourceLocation(Loc, Record);
3106 
3107  Record.push_back(FileIDAndFile.second.StateTransitions.size());
3108  for (auto &StatePoint : FileIDAndFile.second.StateTransitions) {
3109  Record.push_back(StatePoint.Offset);
3110  AddDiagState(StatePoint.State, false);
3111  }
3112  }
3113 
3114  // Backpatch the number of locations.
3115  Record[NumLocationsIdx] = NumLocations;
3116 
3117  // Emit CurDiagStateLoc. Do it last in order to match source order.
3118  //
3119  // This also protects against a hypothetical corner case with simulating
3120  // -Werror settings for implicit modules in the ASTReader, where reading
3121  // CurDiagState out of context could change whether warning pragmas are
3122  // treated as errors.
3123  AddSourceLocation(Diag.DiagStatesByLoc.CurDiagStateLoc, Record);
3124  AddDiagState(Diag.DiagStatesByLoc.CurDiagState, false);
3125 
3126  Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record);
3127 }
3128 
3129 //===----------------------------------------------------------------------===//
3130 // Type Serialization
3131 //===----------------------------------------------------------------------===//
3132 
3133 /// Write the representation of a type to the AST stream.
3134 void ASTWriter::WriteType(QualType T) {
3135  TypeIdx &IdxRef = TypeIdxs[T];
3136  if (IdxRef.getIndex() == 0) // we haven't seen this type before.
3137  IdxRef = TypeIdx(NextTypeID++);
3138  TypeIdx Idx = IdxRef;
3139 
3140  assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST");
3141 
3142  RecordData Record;
3143 
3144  // Emit the type's representation.
3145  ASTTypeWriter W(*this, Record);
3146  W.Visit(T);
3147  uint64_t Offset = W.Emit();
3148 
3149  // Record the offset for this type.
3150  unsigned Index = Idx.getIndex() - FirstTypeID;
3151  if (TypeOffsets.size() == Index)
3152  TypeOffsets.push_back(Offset);
3153  else if (TypeOffsets.size() < Index) {
3154  TypeOffsets.resize(Index + 1);
3155  TypeOffsets[Index] = Offset;
3156  } else {
3157  llvm_unreachable("Types emitted in wrong order");
3158  }
3159 }
3160 
3161 //===----------------------------------------------------------------------===//
3162 // Declaration Serialization
3163 //===----------------------------------------------------------------------===//
3164 
3165 /// Write the block containing all of the declaration IDs
3166 /// lexically declared within the given DeclContext.
3167 ///
3168 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
3169 /// bitstream, or 0 if no block was written.
3170 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
3171  DeclContext *DC) {
3172  if (DC->decls_empty())
3173  return 0;
3174 
3175  uint64_t Offset = Stream.GetCurrentBitNo();
3176  SmallVector<uint32_t, 128> KindDeclPairs;
3177  for (const auto *D : DC->decls()) {
3178  KindDeclPairs.push_back(D->getKind());
3179  KindDeclPairs.push_back(GetDeclRef(D));
3180  }
3181 
3182  ++NumLexicalDeclContexts;
3183  RecordData::value_type Record[] = {DECL_CONTEXT_LEXICAL};
3184  Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record,
3185  bytes(KindDeclPairs));
3186  return Offset;
3187 }
3188 
3189 void ASTWriter::WriteTypeDeclOffsets() {
3190  using namespace llvm;
3191 
3192  // Write the type offsets array
3193  auto Abbrev = std::make_shared<BitCodeAbbrev>();
3194  Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET));
3195  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types
3196  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index
3197  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block
3198  unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3199  {
3200  RecordData::value_type Record[] = {TYPE_OFFSET, TypeOffsets.size(),
3201  FirstTypeID - NUM_PREDEF_TYPE_IDS};
3202  Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, bytes(TypeOffsets));
3203  }
3204 
3205  // Write the declaration offsets array
3206  Abbrev = std::make_shared<BitCodeAbbrev>();
3207  Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET));
3208  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations
3209  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID
3210  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block
3211  unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3212  {
3213  RecordData::value_type Record[] = {DECL_OFFSET, DeclOffsets.size(),
3214  FirstDeclID - NUM_PREDEF_DECL_IDS};
3215  Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, bytes(DeclOffsets));
3216  }
3217 }
3218 
3219 void ASTWriter::WriteFileDeclIDsMap() {
3220  using namespace llvm;
3221 
3223  FileDeclIDs.begin(), FileDeclIDs.end());
3224  llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(),
3225  llvm::less_first());
3226 
3227  // Join the vectors of DeclIDs from all files.
3228  SmallVector<DeclID, 256> FileGroupedDeclIDs;
3229  for (auto &FileDeclEntry : SortedFileDeclIDs) {
3230  DeclIDInFileInfo &Info = *FileDeclEntry.second;
3231  Info.FirstDeclIndex = FileGroupedDeclIDs.size();
3232  for (auto &LocDeclEntry : Info.DeclIDs)
3233  FileGroupedDeclIDs.push_back(LocDeclEntry.second);
3234  }
3235 
3236  auto Abbrev = std::make_shared<BitCodeAbbrev>();
3237  Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS));
3238  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3239  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3240  unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
3241  RecordData::value_type Record[] = {FILE_SORTED_DECLS,
3242  FileGroupedDeclIDs.size()};
3243  Stream.EmitRecordWithBlob(AbbrevCode, Record, bytes(FileGroupedDeclIDs));
3244 }
3245 
3246 void ASTWriter::WriteComments() {
3247  Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3);
3248  ArrayRef<RawComment *> RawComments = Context->Comments.getComments();
3249  RecordData Record;
3250  for (const auto *I : RawComments) {
3251  Record.clear();
3252  AddSourceRange(I->getSourceRange(), Record);
3253  Record.push_back(I->getKind());
3254  Record.push_back(I->isTrailingComment());
3255  Record.push_back(I->isAlmostTrailingComment());
3256  Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record);
3257  }
3258  Stream.ExitBlock();
3259 }
3260 
3261 //===----------------------------------------------------------------------===//
3262 // Global Method Pool and Selector Serialization
3263 //===----------------------------------------------------------------------===//
3264 
3265 namespace {
3266 
3267 // Trait used for the on-disk hash table used in the method pool.
3268 class ASTMethodPoolTrait {
3269  ASTWriter &Writer;
3270 
3271 public:
3272  using key_type = Selector;
3273  using key_type_ref = key_type;
3274 
3275  struct data_type {
3276  SelectorID ID;
3277  ObjCMethodList Instance, Factory;
3278  };
3279  using data_type_ref = const data_type &;
3280 
3281  using hash_value_type = unsigned;
3282  using offset_type = unsigned;
3283 
3284  explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) {}
3285 
3286  static hash_value_type ComputeHash(Selector Sel) {
3287  return serialization::ComputeHash(Sel);
3288  }
3289 
3290  std::pair<unsigned, unsigned>
3291  EmitKeyDataLength(raw_ostream& Out, Selector Sel,
3292  data_type_ref Methods) {
3293  using namespace llvm::support;
3294 
3295  endian::Writer LE(Out, little);
3296  unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
3297  LE.write<uint16_t>(KeyLen);
3298  unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
3299  for (const ObjCMethodList *Method = &Methods.Instance; Method;
3300  Method = Method->getNext())
3301  if (Method->getMethod())
3302  DataLen += 4;
3303  for (const ObjCMethodList *Method = &Methods.Factory; Method;
3304  Method = Method->getNext())
3305  if (Method->getMethod())
3306  DataLen += 4;
3307  LE.write<uint16_t>(DataLen);
3308  return std::make_pair(KeyLen, DataLen);
3309  }
3310 
3311  void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
3312  using namespace llvm::support;
3313 
3314  endian::Writer LE(Out, little);
3315  uint64_t Start = Out.tell();
3316  assert((Start >> 32) == 0 && "Selector key offset too large");
3317  Writer.SetSelectorOffset(Sel, Start);
3318  unsigned N = Sel.getNumArgs();
3319  LE.write<uint16_t>(N);
3320  if (N == 0)
3321  N = 1;
3322  for (unsigned I = 0; I != N; ++I)
3323  LE.write<uint32_t>(
3325  }
3326 
3327  void EmitData(raw_ostream& Out, key_type_ref,
3328  data_type_ref Methods, unsigned DataLen) {
3329  using namespace llvm::support;
3330 
3331  endian::Writer LE(Out, little);
3332  uint64_t Start = Out.tell(); (void)Start;
3333  LE.write<uint32_t>(Methods.ID);
3334  unsigned NumInstanceMethods = 0;
3335  for (const ObjCMethodList *Method = &Methods.Instance; Method;
3336  Method = Method->getNext())
3337  if (Method->getMethod())
3338  ++NumInstanceMethods;
3339 
3340  unsigned NumFactoryMethods = 0;
3341  for (const ObjCMethodList *Method = &Methods.Factory; Method;
3342  Method = Method->getNext())
3343  if (Method->getMethod())
3344  ++NumFactoryMethods;
3345 
3346  unsigned InstanceBits = Methods.Instance.getBits();
3347  assert(InstanceBits < 4);
3348  unsigned InstanceHasMoreThanOneDeclBit =
3349  Methods.Instance.hasMoreThanOneDecl();
3350  unsigned FullInstanceBits = (NumInstanceMethods << 3) |
3351  (InstanceHasMoreThanOneDeclBit << 2) |
3352  InstanceBits;
3353  unsigned FactoryBits = Methods.Factory.getBits();
3354  assert(FactoryBits < 4);
3355  unsigned FactoryHasMoreThanOneDeclBit =
3356  Methods.Factory.hasMoreThanOneDecl();
3357  unsigned FullFactoryBits = (NumFactoryMethods << 3) |
3358  (FactoryHasMoreThanOneDeclBit << 2) |
3359  FactoryBits;
3360  LE.write<uint16_t>(FullInstanceBits);
3361  LE.write<uint16_t>(FullFactoryBits);
3362  for (const ObjCMethodList *Method = &Methods.Instance; Method;
3363  Method = Method->getNext())
3364  if (Method->getMethod())
3365  LE.write<uint32_t>(Writer.getDeclID(Method->getMethod()));
3366  for (const ObjCMethodList *Method = &Methods.Factory; Method;
3367  Method = Method->getNext())
3368  if (Method->getMethod())
3369  LE.write<uint32_t>(Writer.getDeclID(Method->getMethod()));
3370 
3371  assert(Out.tell() - Start == DataLen && "Data length is wrong");
3372  }
3373 };
3374 
3375 } // namespace
3376 
3377 /// Write ObjC data: selectors and the method pool.
3378 ///
3379 /// The method pool contains both instance and factory methods, stored
3380 /// in an on-disk hash table indexed by the selector. The hash table also
3381 /// contains an empty entry for every other selector known to Sema.
3382 void ASTWriter::WriteSelectors(Sema &SemaRef) {
3383  using namespace llvm;
3384 
3385  // Do we have to do anything at all?
3386  if (SemaRef.MethodPool.empty() && SelectorIDs.empty())
3387  return;
3388  unsigned NumTableEntries = 0;
3389  // Create and write out the blob that contains selectors and the method pool.
3390  {
3391  llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
3392  ASTMethodPoolTrait Trait(*this);
3393 
3394  // Create the on-disk hash table representation. We walk through every
3395  // selector we've seen and look it up in the method pool.
3396  SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
3397  for (auto &SelectorAndID : SelectorIDs) {
3398  Selector S = SelectorAndID.first;
3399  SelectorID ID = SelectorAndID.second;
3400  Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S);
3401  ASTMethodPoolTrait::data_type Data = {
3402  ID,
3403  ObjCMethodList(),
3404  ObjCMethodList()
3405  };
3406  if (F != SemaRef.MethodPool.end()) {
3407  Data.Instance = F->second.first;
3408  Data.Factory = F->second.second;
3409  }
3410  // Only write this selector if it's not in an existing AST or something
3411  // changed.
3412  if (Chain && ID < FirstSelectorID) {
3413  // Selector already exists. Did it change?
3414  bool changed = false;
3415  for (ObjCMethodList *M = &Data.Instance;
3416  !changed && M && M->getMethod(); M = M->getNext()) {
3417  if (!M->getMethod()->isFromASTFile())
3418  changed = true;
3419  }
3420  for (ObjCMethodList *M = &Data.Factory; !changed && M && M->getMethod();
3421  M = M->getNext()) {
3422  if (!M->getMethod()->isFromASTFile())
3423  changed = true;
3424  }
3425  if (!changed)
3426  continue;
3427  } else if (Data.Instance.getMethod() || Data.Factory.getMethod()) {
3428  // A new method pool entry.
3429  ++NumTableEntries;
3430  }
3431  Generator.insert(S, Data, Trait);
3432  }
3433 
3434  // Create the on-disk hash table in a buffer.
3435  SmallString<4096> MethodPool;
3436  uint32_t BucketOffset;
3437  {
3438  using namespace llvm::support;
3439 
3440  ASTMethodPoolTrait Trait(*this);
3441  llvm::raw_svector_ostream Out(MethodPool);
3442  // Make sure that no bucket is at offset 0
3443  endian::write<uint32_t>(Out, 0, little);
3444  BucketOffset = Generator.Emit(Out, Trait);
3445  }
3446 
3447  // Create a blob abbreviation
3448  auto Abbrev = std::make_shared<BitCodeAbbrev>();
3449  Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
3450  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3451  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3452  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3453  unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3454 
3455  // Write the method pool
3456  {
3457  RecordData::value_type Record[] = {METHOD_POOL, BucketOffset,
3458  NumTableEntries};
3459  Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool);
3460  }
3461 
3462  // Create a blob abbreviation for the selector table offsets.
3463  Abbrev = std::make_shared<BitCodeAbbrev>();
3464  Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
3465  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
3466  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
3467  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3468  unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3469 
3470  // Write the selector offsets table.
3471  {
3472  RecordData::value_type Record[] = {
3473  SELECTOR_OFFSETS, SelectorOffsets.size(),
3474  FirstSelectorID - NUM_PREDEF_SELECTOR_IDS};
3475  Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
3476  bytes(SelectorOffsets));
3477  }
3478  }
3479 }
3480 
3481 /// Write the selectors referenced in @selector expression into AST file.
3482 void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
3483  using namespace llvm;
3484 
3485  if (SemaRef.ReferencedSelectors.empty())
3486  return;
3487 
3488  RecordData Record;
3489  ASTRecordWriter Writer(*this, Record);
3490 
3491  // Note: this writes out all references even for a dependent AST. But it is
3492  // very tricky to fix, and given that @selector shouldn't really appear in
3493  // headers, probably not worth it. It's not a correctness issue.
3494  for (auto &SelectorAndLocation : SemaRef.ReferencedSelectors) {
3495  Selector Sel = SelectorAndLocation.first;
3496  SourceLocation Loc = SelectorAndLocation.second;
3497  Writer.AddSelectorRef(Sel);
3498  Writer.AddSourceLocation(Loc);
3499  }
3501 }
3502 
3503 //===----------------------------------------------------------------------===//
3504 // Identifier Table Serialization
3505 //===----------------------------------------------------------------------===//
3506 
3507 /// Determine the declaration that should be put into the name lookup table to
3508 /// represent the given declaration in this module. This is usually D itself,
3509 /// but if D was imported and merged into a local declaration, we want the most
3510 /// recent local declaration instead. The chosen declaration will be the most
3511 /// recent declaration in any module that imports this one.
3513  NamedDecl *D) {
3514  if (!LangOpts.Modules || !D->isFromASTFile())
3515  return D;
3516 
3517  if (Decl *Redecl = D->getPreviousDecl()) {
3518  // For Redeclarable decls, a prior declaration might be local.
3519  for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
3520  // If we find a local decl, we're done.
3521  if (!Redecl->isFromASTFile()) {
3522  // Exception: in very rare cases (for injected-class-names), not all
3523  // redeclarations are in the same semantic context. Skip ones in a
3524  // different context. They don't go in this lookup table at all.
3525  if (!Redecl->getDeclContext()->getRedeclContext()->Equals(
3527  continue;
3528  return cast<NamedDecl>(Redecl);
3529  }
3530 
3531  // If we find a decl from a (chained-)PCH stop since we won't find a
3532  // local one.
3533  if (Redecl->getOwningModuleID() == 0)
3534  break;
3535  }
3536  } else if (Decl *First = D->getCanonicalDecl()) {
3537  // For Mergeable decls, the first decl might be local.
3538  if (!First->isFromASTFile())
3539  return cast<NamedDecl>(First);
3540  }
3541 
3542  // All declarations are imported. Our most recent declaration will also be
3543  // the most recent one in anyone who imports us.
3544  return D;
3545 }
3546 
3547 namespace {
3548 
3549 class ASTIdentifierTableTrait {
3550  ASTWriter &Writer;
3551  Preprocessor &PP;
3552  IdentifierResolver &IdResolver;
3553  bool IsModule;
3554  bool NeedDecls;
3555  ASTWriter::RecordData *InterestingIdentifierOffsets;
3556 
3557  /// Determines whether this is an "interesting" identifier that needs a
3558  /// full IdentifierInfo structure written into the hash table. Notably, this
3559  /// doesn't check whether the name has macros defined; use PublicMacroIterator
3560  /// to check that.
3561  bool isInterestingIdentifier(const IdentifierInfo *II, uint64_t MacroOffset) {
3562  if (MacroOffset ||
3563  II->isPoisoned() ||
3564  (IsModule ? II->hasRevertedBuiltin() : II->getObjCOrBuiltinID()) ||
3566  (NeedDecls && II->getFETokenInfo<void>()))
3567  return true;
3568 
3569  return false;
3570  }
3571 
3572 public:
3573  using key_type = IdentifierInfo *;
3574  using key_type_ref = key_type;
3575 
3576  using data_type = IdentID;
3577  using data_type_ref = data_type;
3578 
3579  using hash_value_type = unsigned;
3580  using offset_type = unsigned;
3581 
3582  ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP,
3583  IdentifierResolver &IdResolver, bool IsModule,
3584  ASTWriter::RecordData *InterestingIdentifierOffsets)
3585  : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule),
3586  NeedDecls(!IsModule || !Writer.getLangOpts().CPlusPlus),
3587  InterestingIdentifierOffsets(InterestingIdentifierOffsets) {}
3588 
3589  bool needDecls() const { return NeedDecls; }
3590 
3591  static hash_value_type ComputeHash(const IdentifierInfo* II) {
3592  return llvm::djbHash(II->getName());
3593  }
3594 
3595  bool isInterestingIdentifier(const IdentifierInfo *II) {
3596  auto MacroOffset = Writer.getMacroDirectivesOffset(II);
3597  return isInterestingIdentifier(II, MacroOffset);
3598  }
3599 
3600  bool isInterestingNonMacroIdentifier(const IdentifierInfo *II) {
3601  return isInterestingIdentifier(II, 0);
3602  }
3603 
3604  std::pair<unsigned, unsigned>
3605  EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) {
3606  unsigned KeyLen = II->getLength() + 1;
3607  unsigned DataLen = 4; // 4 bytes for the persistent ID << 1
3608  auto MacroOffset = Writer.getMacroDirectivesOffset(II);
3609  if (isInterestingIdentifier(II, MacroOffset)) {
3610  DataLen += 2; // 2 bytes for builtin ID
3611  DataLen += 2; // 2 bytes for flags
3612  if (MacroOffset)
3613  DataLen += 4; // MacroDirectives offset.
3614 
3615  if (NeedDecls) {
3616  for (IdentifierResolver::iterator D = IdResolver.begin(II),
3617  DEnd = IdResolver.end();
3618  D != DEnd; ++D)
3619  DataLen += 4;
3620  }
3621  }
3622 
3623  using namespace llvm::support;
3624 
3625  endian::Writer LE(Out, little);
3626 
3627  assert((uint16_t)DataLen == DataLen && (uint16_t)KeyLen == KeyLen);
3628  LE.write<uint16_t>(DataLen);
3629  // We emit the key length after the data length so that every
3630  // string is preceded by a 16-bit length. This matches the PTH
3631  // format for storing identifiers.
3632  LE.write<uint16_t>(KeyLen);
3633  return std::make_pair(KeyLen, DataLen);
3634  }
3635 
3636  void EmitKey(raw_ostream& Out, const IdentifierInfo* II,
3637  unsigned KeyLen) {
3638  // Record the location of the key data. This is used when generating
3639  // the mapping from persistent IDs to strings.
3640  Writer.SetIdentifierOffset(II, Out.tell());
3641 
3642  // Emit the offset of the key/data length information to the interesting
3643  // identifiers table if necessary.
3644  if (InterestingIdentifierOffsets && isInterestingIdentifier(II))
3645  InterestingIdentifierOffsets->push_back(Out.tell() - 4);
3646 
3647  Out.write(II->getNameStart(), KeyLen);
3648  }
3649 
3650  void EmitData(raw_ostream& Out, IdentifierInfo* II,
3651  IdentID ID, unsigned) {
3652  using namespace llvm::support;
3653 
3654  endian::Writer LE(Out, little);
3655 
3656  auto MacroOffset = Writer.getMacroDirectivesOffset(II);
3657  if (!isInterestingIdentifier(II, MacroOffset)) {
3658  LE.write<uint32_t>(ID << 1);
3659  return;
3660  }
3661 
3662  LE.write<uint32_t>((ID << 1) | 0x01);
3663  uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID();
3664  assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader.");
3665  LE.write<uint16_t>(Bits);
3666  Bits = 0;
3667  bool HadMacroDefinition = MacroOffset != 0;
3668  Bits = (Bits << 1) | unsigned(HadMacroDefinition);
3669  Bits = (Bits << 1) | unsigned(II->isExtensionToken());
3670  Bits = (Bits << 1) | unsigned(II->isPoisoned());
3671  Bits = (Bits << 1) | unsigned(II->hasRevertedBuiltin());
3672  Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
3673  Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
3674  LE.write<uint16_t>(Bits);
3675 
3676  if (HadMacroDefinition)
3677  LE.write<uint32_t>(MacroOffset);
3678 
3679  if (NeedDecls) {
3680  // Emit the declaration IDs in reverse order, because the
3681  // IdentifierResolver provides the declarations as they would be
3682  // visible (e.g., the function "stat" would come before the struct
3683  // "stat"), but the ASTReader adds declarations to the end of the list
3684  // (so we need to see the struct "stat" before the function "stat").
3685  // Only emit declarations that aren't from a chained PCH, though.
3686  SmallVector<NamedDecl *, 16> Decls(IdResolver.begin(II),
3687  IdResolver.end());
3688  for (SmallVectorImpl<NamedDecl *>::reverse_iterator D = Decls.rbegin(),
3689  DEnd = Decls.rend();
3690  D != DEnd; ++D)
3691  LE.write<uint32_t>(
3692  Writer.getDeclID(getDeclForLocalLookup(PP.getLangOpts(), *D)));
3693  }
3694  }
3695 };
3696 
3697 } // namespace
3698 
3699 /// Write the identifier table into the AST file.
3700 ///
3701 /// The identifier table consists of a blob containing string data
3702 /// (the actual identifiers themselves) and a separate "offsets" index
3703 /// that maps identifier IDs to locations within the blob.
3704 void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
3705  IdentifierResolver &IdResolver,
3706  bool IsModule) {
3707  using namespace llvm;
3708 
3709  RecordData InterestingIdents;
3710 
3711  // Create and write out the blob that contains the identifier
3712  // strings.
3713  {
3714  llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
3715  ASTIdentifierTableTrait Trait(
3716  *this, PP, IdResolver, IsModule,
3717  (getLangOpts().CPlusPlus && IsModule) ? &InterestingIdents : nullptr);
3718 
3719  // Look for any identifiers that were named while processing the
3720  // headers, but are otherwise not needed. We add these to the hash
3721  // table to enable checking of the predefines buffer in the case
3722  // where the user adds new macro definitions when building the AST
3723  // file.
3725  for (const auto &ID : PP.getIdentifierTable())
3726  IIs.push_back(ID.second);
3727  // Sort the identifiers lexicographically before getting them references so
3728  // that their order is stable.
3729  llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
3730  for (const IdentifierInfo *II : IIs)
3731  if (Trait.isInterestingNonMacroIdentifier(II))
3732  getIdentifierRef(II);
3733 
3734  // Create the on-disk hash table representation. We only store offsets
3735  // for identifiers that appear here for the first time.
3736  IdentifierOffsets.resize(NextIdentID - FirstIdentID);
3737  for (auto IdentIDPair : IdentifierIDs) {
3738  auto *II = const_cast<IdentifierInfo *>(IdentIDPair.first);
3739  IdentID ID = IdentIDPair.second;
3740  assert(II && "NULL identifier in identifier table");
3741  // Write out identifiers if either the ID is local or the identifier has
3742  // changed since it was loaded.
3743  if (ID >= FirstIdentID || !Chain || !II->isFromAST()
3744  || II->hasChangedSinceDeserialization() ||
3745  (Trait.needDecls() &&
3746  II->hasFETokenInfoChangedSinceDeserialization()))
3747  Generator.insert(II, ID, Trait);
3748  }
3749 
3750  // Create the on-disk hash table in a buffer.
3752  uint32_t BucketOffset;
3753  {
3754  using namespace llvm::support;
3755 
3756  llvm::raw_svector_ostream Out(IdentifierTable);
3757  // Make sure that no bucket is at offset 0
3758  endian::write<uint32_t>(Out, 0, little);
3759  BucketOffset = Generator.Emit(Out, Trait);
3760  }
3761 
3762  // Create a blob abbreviation
3763  auto Abbrev = std::make_shared<BitCodeAbbrev>();
3764  Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
3765  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3766  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3767  unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3768 
3769  // Write the identifier table
3770  RecordData::value_type Record[] = {IDENTIFIER_TABLE, BucketOffset};
3771  Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable);
3772  }
3773 
3774  // Write the offsets table for identifier IDs.
3775  auto Abbrev = std::make_shared<BitCodeAbbrev>();
3776  Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
3777  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
3778  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
3779  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3780  unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3781 
3782 #ifndef NDEBUG
3783  for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
3784  assert(IdentifierOffsets[I] && "Missing identifier offset?");
3785 #endif
3786 
3787  RecordData::value_type Record[] = {IDENTIFIER_OFFSET,
3788  IdentifierOffsets.size(),
3789  FirstIdentID - NUM_PREDEF_IDENT_IDS};
3790  Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
3791  bytes(IdentifierOffsets));
3792 
3793  // In C++, write the list of interesting identifiers (those that are
3794  // defined as macros, poisoned, or similar unusual things).
3795  if (!InterestingIdents.empty())
3796  Stream.EmitRecord(INTERESTING_IDENTIFIERS, InterestingIdents);
3797 }
3798 
3799 //===----------------------------------------------------------------------===//
3800 // DeclContext's Name Lookup Table Serialization
3801 //===----------------------------------------------------------------------===//
3802 
3803 namespace {
3804 
3805 // Trait used for the on-disk hash table used in the method pool.
3806 class ASTDeclContextNameLookupTrait {
3807  ASTWriter &Writer;
3809 
3810 public:
3811  using key_type = DeclarationNameKey;
3812  using key_type_ref = key_type;
3813 
3814  /// A start and end index into DeclIDs, representing a sequence of decls.
3815  using data_type = std::pair<unsigned, unsigned>;
3816  using data_type_ref = const data_type &;
3817 
3818  using hash_value_type = unsigned;
3819  using offset_type = unsigned;
3820 
3821  explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) {}
3822 
3823  template<typename Coll>
3824  data_type getData(const Coll &Decls) {
3825  unsigned Start = DeclIDs.size();
3826  for (NamedDecl *D : Decls) {
3827  DeclIDs.push_back(
3828  Writer.GetDeclRef(getDeclForLocalLookup(Writer.getLangOpts(), D)));
3829  }
3830  return std::make_pair(Start, DeclIDs.size());
3831  }
3832 
3833  data_type ImportData(const reader::ASTDeclContextNameLookupTrait::data_type &FromReader) {
3834  unsigned Start = DeclIDs.size();
3835  for (auto ID : FromReader)
3836  DeclIDs.push_back(ID);
3837  return std::make_pair(Start, DeclIDs.size());
3838  }
3839 
3840  static bool EqualKey(key_type_ref a, key_type_ref b) {
3841  return a == b;
3842  }
3843 
3844  hash_value_type ComputeHash(DeclarationNameKey Name) {
3845  return Name.getHash();
3846  }
3847 
3848  void EmitFileRef(raw_ostream &Out, ModuleFile *F) const {
3849  assert(Writer.hasChain() &&
3850  "have reference to loaded module file but no chain?");
3851 
3852  using namespace llvm::support;
3853 
3854  endian::write<uint32_t>(Out, Writer.getChain()->getModuleFileID(F), little);
3855  }
3856 
3857  std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
3858  DeclarationNameKey Name,
3859  data_type_ref Lookup) {
3860  using namespace llvm::support;
3861 
3862  endian::Writer LE(Out, little);
3863  unsigned KeyLen = 1;
3864  switch (Name.getKind()) {
3871  KeyLen += 4;
3872  break;
3874  KeyLen += 1;
3875  break;
3880  break;
3881  }
3882  LE.write<uint16_t>(KeyLen);
3883 
3884  // 4 bytes for each DeclID.
3885  unsigned DataLen = 4 * (Lookup.second - Lookup.first);
3886  assert(uint16_t(DataLen) == DataLen &&
3887  "too many decls for serialized lookup result");
3888  LE.write<uint16_t>(DataLen);
3889 
3890  return std::make_pair(KeyLen, DataLen);
3891  }
3892 
3893  void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) {
3894  using namespace llvm::support;
3895 
3896  endian::Writer LE(Out, little);
3897  LE.write<uint8_t>(Name.getKind());
3898  switch (Name.getKind()) {
3902  LE.write<uint32_t>(Writer.getIdentifierRef(Name.getIdentifier()));
3903  return;
3907  LE.write<uint32_t>(Writer.getSelectorRef(Name.getSelector()));
3908  return;
3910  assert(Name.getOperatorKind() < NUM_OVERLOADED_OPERATORS &&
3911  "Invalid operator?");
3912  LE.write<uint8_t>(Name.getOperatorKind());
3913  return;
3918  return;
3919  }
3920 
3921  llvm_unreachable("Invalid name kind?");
3922  }
3923 
3924  void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
3925  unsigned DataLen) {
3926  using namespace llvm::support;
3927 
3928  endian::Writer LE(Out, little);
3929  uint64_t Start = Out.tell(); (void)Start;
3930  for (unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
3931  LE.write<uint32_t>(DeclIDs[I]);
3932  assert(Out.tell() - Start == DataLen && "Data length is wrong");
3933  }
3934 };
3935 
3936 } // namespace
3937 
3938 bool ASTWriter::isLookupResultExternal(StoredDeclsList &Result,
3939  DeclContext *DC) {
3940  return Result.hasExternalDecls() && DC->NeedToReconcileExternalVisibleStorage;
3941 }
3942 
3943 bool ASTWriter::isLookupResultEntirelyExternal(StoredDeclsList &Result,
3944  DeclContext *DC) {
3945  for (auto *D : Result.getLookupResult())
3946  if (!getDeclForLocalLookup(getLangOpts(), D)->isFromASTFile())
3947  return false;
3948 
3949  return true;
3950 }
3951 
3952 void
3953 ASTWriter::GenerateNameLookupTable(const DeclContext *ConstDC,
3954  llvm::SmallVectorImpl<char> &LookupTable) {
3955  assert(!ConstDC->HasLazyLocalLexicalLookups &&
3956  !ConstDC->HasLazyExternalLexicalLookups &&
3957  "must call buildLookups first");
3958 
3959  // FIXME: We need to build the lookups table, which is logically const.
3960  auto *DC = const_cast<DeclContext*>(ConstDC);
3961  assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table");
3962 
3963  // Create the on-disk hash table representation.
3965  ASTDeclContextNameLookupTrait> Generator;
3966  ASTDeclContextNameLookupTrait Trait(*this);
3967 
3968  // The first step is to collect the declaration names which we need to
3969  // serialize into the name lookup table, and to collect them in a stable
3970  // order.
3972 
3973  // We also build up small sets of the constructor and conversion function
3974  // names which are visible.
3975  llvm::SmallSet<DeclarationName, 8> ConstructorNameSet, ConversionNameSet;
3976 
3977  for (auto &Lookup : *DC->buildLookup()) {
3978  auto &Name = Lookup.first;
3979  auto &Result = Lookup.second;
3980 
3981  // If there are no local declarations in our lookup result, we
3982  // don't need to write an entry for the name at all. If we can't
3983  // write out a lookup set without performing more deserialization,
3984  // just skip this entry.
3985  if (isLookupResultExternal(Result, DC) &&
3986  isLookupResultEntirelyExternal(Result, DC))
3987  continue;
3988 
3989  // We also skip empty results. If any of the results could be external and
3990  // the currently available results are empty, then all of the results are
3991  // external and we skip it above. So the only way we get here with an empty
3992  // results is when no results could have been external *and* we have
3993  // external results.
3994  //
3995  // FIXME: While we might want to start emitting on-disk entries for negative
3996  // lookups into a decl context as an optimization, today we *have* to skip
3997  // them because there are names with empty lookup results in decl contexts
3998  // which we can't emit in any stable ordering: we lookup constructors and
3999  // conversion functions in the enclosing namespace scope creating empty
4000  // results for them. This in almost certainly a bug in Clang's name lookup,
4001  // but that is likely to be hard or impossible to fix and so we tolerate it
4002  // here by omitting lookups with empty results.
4003  if (Lookup.second.getLookupResult().empty())
4004  continue;
4005 
4006  switch (Lookup.first.getNameKind()) {
4007  default:
4008  Names.push_back(Lookup.first);
4009  break;
4010 
4012  assert(isa<CXXRecordDecl>(DC) &&
4013  "Cannot have a constructor name outside of a class!");
4014  ConstructorNameSet.insert(Name);
4015  break;
4016 
4018  assert(isa<CXXRecordDecl>(DC) &&
4019  "Cannot have a conversion function name outside of a class!");
4020  ConversionNameSet.insert(Name);
4021  break;
4022  }
4023  }
4024 
4025  // Sort the names into a stable order.
4026  llvm::sort(Names.begin(), Names.end());
4027 
4028  if (auto *D = dyn_cast<CXXRecordDecl>(DC)) {
4029  // We need to establish an ordering of constructor and conversion function
4030  // names, and they don't have an intrinsic ordering.
4031 
4032  // First we try the easy case by forming the current context's constructor
4033  // name and adding that name first. This is a very useful optimization to
4034  // avoid walking the lexical declarations in many cases, and it also
4035  // handles the only case where a constructor name can come from some other
4036  // lexical context -- when that name is an implicit constructor merged from
4037  // another declaration in the redecl chain. Any non-implicit constructor or
4038  // conversion function which doesn't occur in all the lexical contexts
4039  // would be an ODR violation.
4040  auto ImplicitCtorName = Context->DeclarationNames.getCXXConstructorName(
4041  Context->getCanonicalType(Context->getRecordType(D)));
4042  if (ConstructorNameSet.erase(ImplicitCtorName))
4043  Names.push_back(ImplicitCtorName);
4044 
4045  // If we still have constructors or conversion functions, we walk all the
4046  // names in the decl and add the constructors and conversion functions
4047  // which are visible in the order they lexically occur within the context.
4048  if (!ConstructorNameSet.empty() || !ConversionNameSet.empty())
4049  for (Decl *ChildD : cast<CXXRecordDecl>(DC)->decls())
4050  if (auto *ChildND = dyn_cast<NamedDecl>(ChildD)) {
4051  auto Name = ChildND->getDeclName();
4052  switch (Name.getNameKind()) {
4053  default:
4054  continue;
4055 
4057  if (ConstructorNameSet.erase(Name))
4058  Names.push_back(Name);
4059  break;
4060 
4062  if (ConversionNameSet.erase(Name))
4063  Names.push_back(Name);
4064  break;
4065  }
4066 
4067  if (ConstructorNameSet.empty() && ConversionNameSet.empty())
4068  break;
4069  }
4070 
4071  assert(ConstructorNameSet.empty() && "Failed to find all of the visible "
4072  "constructors by walking all the "
4073  "lexical members of the context.");
4074  assert(ConversionNameSet.empty() && "Failed to find all of the visible "
4075  "conversion functions by walking all "
4076  "the lexical members of the context.");
4077  }
4078 
4079  // Next we need to do a lookup with each name into this decl context to fully
4080  // populate any results from external sources. We don't actually use the
4081  // results of these lookups because we only want to use the results after all
4082  // results have been loaded and the pointers into them will be stable.
4083  for (auto &Name : Names)
4084  DC->lookup(Name);
4085 
4086  // Now we need to insert the results for each name into the hash table. For
4087  // constructor names and conversion function names, we actually need to merge
4088  // all of the results for them into one list of results each and insert
4089  // those.
4090  SmallVector<NamedDecl *, 8> ConstructorDecls;
4091  SmallVector<NamedDecl *, 8> ConversionDecls;
4092 
4093  // Now loop over the names, either inserting them or appending for the two
4094  // special cases.
4095  for (auto &Name : Names) {
4096  DeclContext::lookup_result Result = DC->noload_lookup(Name);
4097 
4098  switch (Name.getNameKind()) {
4099  default:
4100  Generator.insert(Name, Trait.getData(Result), Trait);
4101  break;
4102 
4104  ConstructorDecls.append(Result.begin(), Result.end());
4105  break;
4106 
4108  ConversionDecls.append(Result.begin(), Result.end());
4109  break;
4110  }
4111  }
4112 
4113  // Handle our two special cases if we ended up having any. We arbitrarily use
4114  // the first declaration's name here because the name itself isn't part of
4115  // the key, only the kind of name is used.
4116  if (!ConstructorDecls.empty())
4117  Generator.insert(ConstructorDecls.front()->getDeclName(),
4118  Trait.getData(ConstructorDecls), Trait);
4119  if (!ConversionDecls.empty())
4120  Generator.insert(ConversionDecls.front()->getDeclName(),
4121  Trait.getData(ConversionDecls), Trait);
4122 
4123  // Create the on-disk hash table. Also emit the existing imported and
4124  // merged table if there is one.
4125  auto *Lookups = Chain ? Chain->getLoadedLookupTables(DC) : nullptr;
4126  Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table : nullptr);
4127 }
4128 
4129 /// Write the block containing all of the declaration IDs
4130 /// visible from the given DeclContext.
4131 ///
4132 /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
4133 /// bitstream, or 0 if no block was written.
4134 uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
4135  DeclContext *DC) {
4136  // If we imported a key declaration of this namespace, write the visible
4137  // lookup results as an update record for it rather than including them
4138  // on this declaration. We will only look at key declarations on reload.
4139  if (isa<NamespaceDecl>(DC) && Chain &&
4140  Chain->getKeyDeclaration(cast<Decl>(DC))->isFromASTFile()) {
4141  // Only do this once, for the first local declaration of the namespace.
4142  for (auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;
4143  Prev = Prev->getPreviousDecl())
4144  if (!Prev->isFromASTFile())
4145  return 0;
4146 
4147  // Note that we need to emit an update record for the primary context.
4148  UpdatedDeclContexts.insert(DC->getPrimaryContext());
4149 
4150  // Make sure all visible decls are written. They will be recorded later. We
4151  // do this using a side data structure so we can sort the names into
4152  // a deterministic order.
4155  LookupResults;
4156  if (Map) {
4157  LookupResults.reserve(Map->size());
4158  for (auto &Entry : *Map)
4159  LookupResults.push_back(
4160  std::make_pair(Entry.first, Entry.second.getLookupResult()));
4161  }
4162 
4163  llvm::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first());
4164  for (auto &NameAndResult : LookupResults) {
4165  DeclarationName Name = NameAndResult.first;
4166  DeclContext::lookup_result Result = NameAndResult.second;
4169  // We have to work around a name lookup bug here where negative lookup
4170  // results for these names get cached in namespace lookup tables (these
4171  // names should never be looked up in a namespace).
4172  assert(Result.empty() && "Cannot have a constructor or conversion "
4173  "function name in a namespace!");
4174  continue;
4175  }
4176 
4177  for (NamedDecl *ND : Result)
4178  if (!ND->isFromASTFile())
4179  GetDeclRef(ND);
4180  }
4181 
4182  return 0;
4183  }
4184 
4185  if (DC->getPrimaryContext() != DC)
4186  return 0;
4187 
4188  // Skip contexts which don't support name lookup.
4189  if (!DC->isLookupContext())
4190  return 0;
4191 
4192  // If not in C++, we perform name lookup for the translation unit via the
4193  // IdentifierInfo chains, don't bother to build a visible-declarations table.
4194  if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus)
4195  return 0;
4196 
4197  // Serialize the contents of the mapping used for lookup. Note that,
4198  // although we have two very different code paths, the serialized
4199  // representation is the same for both cases: a declaration name,
4200  // followed by a size, followed by references to the visible
4201  // declarations that have that name.
4202  uint64_t Offset = Stream.GetCurrentBitNo();
4203  StoredDeclsMap *Map = DC->buildLookup();
4204  if (!Map || Map->empty())
4205  return 0;
4206 
4207  // Create the on-disk hash table in a buffer.
4208  SmallString<4096> LookupTable;
4209  GenerateNameLookupTable(DC, LookupTable);
4210 
4211  // Write the lookup table
4212  RecordData::value_type Record[] = {DECL_CONTEXT_VISIBLE};
4213  Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
4214  LookupTable);
4215  ++NumVisibleDeclContexts;
4216  return Offset;
4217 }
4218 
4219 /// Write an UPDATE_VISIBLE block for the given context.
4220 ///
4221 /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing
4222 /// DeclContext in a dependent AST file. As such, they only exist for the TU
4223 /// (in C++), for namespaces, and for classes with forward-declared unscoped
4224 /// enumeration members (in C++11).
4225 void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
4226  StoredDeclsMap *Map = DC->getLookupPtr();
4227  if (!Map || Map->empty())
4228  return;
4229 
4230  // Create the on-disk hash table in a buffer.
4231  SmallString<4096> LookupTable;
4232  GenerateNameLookupTable(DC, LookupTable);
4233 
4234  // If we're updating a namespace, select a key declaration as the key for the
4235  // update record; those are the only ones that will be checked on reload.
4236  if (isa<NamespaceDecl>(DC))
4237  DC = cast<DeclContext>(Chain->getKeyDeclaration(cast<Decl>(DC)));
4238 
4239  // Write the lookup table
4240  RecordData::value_type Record[] = {UPDATE_VISIBLE, getDeclID(cast<Decl>(DC))};
4241  Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable);
4242 }
4243 
4244 /// Write an FP_PRAGMA_OPTIONS block for the given FPOptions.
4245 void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) {
4246  RecordData::value_type Record[] = {Opts.getInt()};
4247  Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record);
4248 }
4249 
4250 /// Write an OPENCL_EXTENSIONS block for the given OpenCLOptions.
4251 void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) {
4252  if (!SemaRef.Context.getLangOpts().OpenCL)
4253  return;
4254 
4255  const OpenCLOptions &Opts = SemaRef.getOpenCLOptions();
4256  RecordData Record;
4257  for (const auto &I:Opts.OptMap) {
4258  AddString(I.getKey(), Record);
4259  auto V = I.getValue();
4260  Record.push_back(V.Supported ? 1 : 0);
4261  Record.push_back(V.Enabled ? 1 : 0);
4262  Record.push_back(V.Avail);
4263  Record.push_back(V.Core);
4264  }
4265  Stream.EmitRecord(OPENCL_EXTENSIONS, Record);
4266 }
4267 
4268 void ASTWriter::WriteOpenCLExtensionTypes(Sema &SemaRef) {
4269  if (!SemaRef.Context.getLangOpts().OpenCL)
4270  return;
4271 
4272  RecordData Record;
4273  for (const auto &I : SemaRef.OpenCLTypeExtMap) {
4274  Record.push_back(
4275  static_cast<unsigned>(getTypeID(I.first->getCanonicalTypeInternal())));
4276  Record.push_back(I.second.size());
4277  for (auto Ext : I.second)
4278  AddString(Ext, Record);
4279  }
4280  Stream.EmitRecord(OPENCL_EXTENSION_TYPES, Record);
4281 }
4282 
4283 void ASTWriter::WriteOpenCLExtensionDecls(Sema &SemaRef) {
4284  if (!SemaRef.Context.getLangOpts().OpenCL)
4285  return;
4286 
4287  RecordData Record;
4288  for (const auto &I : SemaRef.OpenCLDeclExtMap) {
4289  Record.push_back(getDeclID(I.first));
4290  Record.push_back(static_cast<unsigned>(I.second.size()));
4291  for (auto Ext : I.second)
4292  AddString(Ext, Record);
4293  }
4294  Stream.EmitRecord(OPENCL_EXTENSION_DECLS, Record);
4295 }
4296 
4297 void ASTWriter::WriteCUDAPragmas(Sema &SemaRef) {
4298  if (SemaRef.ForceCUDAHostDeviceDepth > 0) {
4299  RecordData::value_type Record[] = {SemaRef.ForceCUDAHostDeviceDepth};
4300  Stream.EmitRecord(CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH, Record);
4301  }
4302 }
4303 
4304 void ASTWriter::WriteObjCCategories() {
4305  SmallVector<ObjCCategoriesInfo, 2> CategoriesMap;
4306  RecordData Categories;
4307 
4308  for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
4309  unsigned Size = 0;
4310  unsigned StartIndex = Categories.size();
4311 
4312  ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I];
4313 
4314  // Allocate space for the size.
4315  Categories.push_back(0);
4316 
4317  // Add the categories.
4319  Cat = Class->known_categories_begin(),
4320  CatEnd = Class->known_categories_end();
4321  Cat != CatEnd; ++Cat, ++Size) {
4322  assert(getDeclID(*Cat) != 0 && "Bogus category");
4323  AddDeclRef(*Cat, Categories);
4324  }
4325 
4326  // Update the size.
4327  Categories[StartIndex] = Size;
4328 
4329  // Record this interface -> category map.
4330  ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex };
4331  CategoriesMap.push_back(CatInfo);
4332  }
4333 
4334  // Sort the categories map by the definition ID, since the reader will be
4335  // performing binary searches on this information.
4336  llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
4337 
4338  // Emit the categories map.
4339  using namespace llvm;
4340 
4341  auto Abbrev = std::make_shared<BitCodeAbbrev>();
4342  Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP));
4343  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
4344  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4345  unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
4346 
4347  RecordData::value_type Record[] = {OBJC_CATEGORIES_MAP, CategoriesMap.size()};
4348  Stream.EmitRecordWithBlob(AbbrevID, Record,
4349  reinterpret_cast<char *>(CategoriesMap.data()),
4350  CategoriesMap.size() * sizeof(ObjCCategoriesInfo));
4351 
4352  // Emit the category lists.
4353  Stream.EmitRecord(OBJC_CATEGORIES, Categories);
4354 }
4355 
4356 void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) {
4358 
4359  if (LPTMap.empty())
4360  return;
4361 
4362  RecordData Record;
4363  for (auto &LPTMapEntry : LPTMap) {
4364  const FunctionDecl *FD = LPTMapEntry.first;
4365  LateParsedTemplate &LPT = *LPTMapEntry.second;
4366  AddDeclRef(FD, Record);
4367  AddDeclRef(LPT.D, Record);
4368  Record.push_back(LPT.Toks.size());
4369 
4370  for (const auto &Tok : LPT.Toks) {
4371  AddToken(Tok, Record);
4372  }
4373  }
4374  Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record);
4375 }
4376 
4377 /// Write the state of 'pragma clang optimize' at the end of the module.
4378 void ASTWriter::WriteOptimizePragmaOptions(Sema &SemaRef) {
4379  RecordData Record;
4380  SourceLocation PragmaLoc = SemaRef.getOptimizeOffPragmaLocation();
4381  AddSourceLocation(PragmaLoc, Record);
4382  Stream.EmitRecord(OPTIMIZE_PRAGMA_OPTIONS, Record);
4383 }
4384 
4385 /// Write the state of 'pragma ms_struct' at the end of the module.
4386 void ASTWriter::WriteMSStructPragmaOptions(Sema &SemaRef) {
4387  RecordData Record;
4388  Record.push_back(SemaRef.MSStructPragmaOn ? PMSST_ON : PMSST_OFF);
4389  Stream.EmitRecord(MSSTRUCT_PRAGMA_OPTIONS, Record);
4390 }
4391 
4392 /// Write the state of 'pragma pointers_to_members' at the end of the
4393 //module.
4394 void ASTWriter::WriteMSPointersToMembersPragmaOptions(Sema &SemaRef) {
4395  RecordData Record;
4396  Record.push_back(SemaRef.MSPointerToMemberRepresentationMethod);
4397  AddSourceLocation(SemaRef.ImplicitMSInheritanceAttrLoc, Record);
4398  Stream.EmitRecord(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS, Record);
4399 }
4400 
4401 /// Write the state of 'pragma pack' at the end of the module.
4402 void ASTWriter::WritePackPragmaOptions(Sema &SemaRef) {
4403  // Don't serialize pragma pack state for modules, since it should only take
4404  // effect on a per-submodule basis.
4405  if (WritingModule)
4406  return;
4407 
4408  RecordData Record;
4409  Record.push_back(SemaRef.PackStack.CurrentValue);
4410  AddSourceLocation(SemaRef.PackStack.CurrentPragmaLocation, Record);
4411  Record.push_back(SemaRef.PackStack.Stack.size());
4412  for (const auto &StackEntry : SemaRef.PackStack.Stack) {
4413  Record.push_back(StackEntry.Value);
4414  AddSourceLocation(StackEntry.PragmaLocation, Record);
4415  AddSourceLocation(StackEntry.PragmaPushLocation, Record);
4416  AddString(StackEntry.StackSlotLabel, Record);
4417  }
4418  Stream.EmitRecord(PACK_PRAGMA_OPTIONS, Record);
4419 }
4420 
4421 void ASTWriter::WriteModuleFileExtension(Sema &SemaRef,
4422  ModuleFileExtensionWriter &Writer) {
4423  // Enter the extension block.
4424  Stream.EnterSubblock(EXTENSION_BLOCK_ID, 4);
4425 
4426  // Emit the metadata record abbreviation.
4427  auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
4428  Abv->Add(llvm::BitCodeAbbrevOp(EXTENSION_METADATA));
4429  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4430  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4431  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4432  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4433  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4434  unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv));
4435 
4436  // Emit the metadata record.
4437  RecordData Record;
4438  auto Metadata = Writer.getExtension()->getExtensionMetadata();
4439  Record.push_back(EXTENSION_METADATA);
4440  Record.push_back(Metadata.MajorVersion);
4441  Record.push_back(Metadata.MinorVersion);
4442  Record.push_back(Metadata.BlockName.size());
4443  Record.push_back(Metadata.UserInfo.size());
4444  SmallString<64> Buffer;
4445  Buffer += Metadata.BlockName;
4446  Buffer += Metadata.UserInfo;
4447  Stream.EmitRecordWithBlob(Abbrev, Record, Buffer);
4448 
4449  // Emit the contents of the extension block.
4450  Writer.writeExtensionContents(SemaRef, Stream);
4451 
4452  // Exit the extension block.
4453  Stream.ExitBlock();
4454 }
4455 
4456 //===----------------------------------------------------------------------===//
4457 // General Serialization Routines
4458 //===----------------------------------------------------------------------===//
4459 
4460 /// Emit the list of attributes to the specified record.
4462  auto &Record = *this;
4463  Record.push_back(Attrs.size());
4464  for (const auto *A : Attrs) {
4465  Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
4466  Record.AddSourceRange(A->getRange());
4467 
4468 #include "clang/Serialization/AttrPCHWrite.inc"
4469  }
4470 }
4471 
4473  AddSourceLocation(Tok.getLocation(), Record);
4474  Record.push_back(Tok.getLength());
4475 
4476  // FIXME: When reading literal tokens, reconstruct the literal pointer
4477  // if it is needed.
4478  AddIdentifierRef(Tok.getIdentifierInfo(), Record);
4479  // FIXME: Should translate token kind to a stable encoding.
4480  Record.push_back(Tok.getKind());
4481  // FIXME: Should translate token flags to a stable encoding.
4482  Record.push_back(Tok.getFlags());
4483 }
4484 
4485 void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) {
4486  Record.push_back(Str.size());
4487  Record.insert(Record.end(), Str.begin(), Str.end());
4488 }
4489 
4491  assert(Context && "should have context when outputting path");
4492 
4493  bool Changed =
4495 
4496  // Remove a prefix to make the path relative, if relevant.
4497  const char *PathBegin = Path.data();
4498  const char *PathPtr =
4499  adjustFilenameForRelocatableAST(PathBegin, BaseDirectory);
4500  if (PathPtr != PathBegin) {
4501  Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin));
4502  Changed = true;
4503  }
4504 
4505  return Changed;
4506 }
4507 
4508 void ASTWriter::AddPath(StringRef Path, RecordDataImpl &Record) {
4509  SmallString<128> FilePath(Path);
4510  PreparePathForOutput(FilePath);
4511  AddString(FilePath, Record);
4512 }
4513 
4514 void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record,
4515  StringRef Path) {
4516  SmallString<128> FilePath(Path);
4517  PreparePathForOutput(FilePath);
4518  Stream.EmitRecordWithBlob(Abbrev, Record, FilePath);
4519 }
4520 
4522  RecordDataImpl &Record) {
4523  Record.push_back(Version.getMajor());
4524  if (Optional<unsigned> Minor = Version.getMinor())
4525  Record.push_back(*Minor + 1);
4526  else
4527  Record.push_back(0);
4528  if (Optional<unsigned> Subminor = Version.getSubminor())
4529  Record.push_back(*Subminor + 1);
4530  else
4531  Record.push_back(0);
4532 }
4533 
4534 /// Note that the identifier II occurs at the given offset
4535 /// within the identifier table.
4537  IdentID ID = IdentifierIDs[II];
4538  // Only store offsets new to this AST file. Other identifier names are looked
4539  // up earlier in the chain and thus don't need an offset.
4540  if (ID >= FirstIdentID)
4541  IdentifierOffsets[ID - FirstIdentID] = Offset;
4542 }
4543 
4544 /// Note that the selector Sel occurs at the given offset
4545 /// within the method pool/selector table.
4547  unsigned ID = SelectorIDs[Sel];
4548  assert(ID && "Unknown selector");
4549  // Don't record offsets for selectors that are also available in a different
4550  // file.
4551  if (ID < FirstSelectorID)
4552  return;
4553  SelectorOffsets[ID - FirstSelectorID] = Offset;
4554 }
4555 
4556 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream,
4557  SmallVectorImpl<char> &Buffer, MemoryBufferCache &PCMCache,
4558  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
4559  bool IncludeTimestamps)
4560  : Stream(Stream), Buffer(Buffer), PCMCache(PCMCache),
4561  IncludeTimestamps(IncludeTimestamps) {
4562  for (const auto &Ext : Extensions) {
4563  if (auto Writer = Ext->createExtensionWriter(*this))
4564  ModuleFileExtensionWriters.push_back(std::move(Writer));
4565  }
4566 }
4567 
4569  llvm::DeleteContainerSeconds(FileDeclIDs);
4570 }
4571 
4573  assert(WritingAST && "can't determine lang opts when not writing AST");
4574  return Context->getLangOpts();
4575 }
4576 
4578  return IncludeTimestamps ? E->getModificationTime() : 0;
4579 }
4580 
4582  const std::string &OutputFile,
4583  Module *WritingModule, StringRef isysroot,
4584  bool hasErrors) {
4585  WritingAST = true;
4586 
4587  ASTHasCompilerErrors = hasErrors;
4588 
4589  // Emit the file header.
4590  Stream.Emit((unsigned)'C', 8);
4591  Stream.Emit((unsigned)'P', 8);
4592  Stream.Emit((unsigned)'C', 8);
4593  Stream.Emit((unsigned)'H', 8);
4594 
4595  WriteBlockInfoBlock();
4596 
4597  Context = &SemaRef.Context;
4598  PP = &SemaRef.PP;
4599  this->WritingModule = WritingModule;
4600  ASTFileSignature Signature =
4601  WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule);
4602  Context = nullptr;
4603  PP = nullptr;
4604  this->WritingModule = nullptr;
4605  this->BaseDirectory.clear();
4606 
4607  WritingAST = false;
4608  if (SemaRef.Context.getLangOpts().ImplicitModules && WritingModule) {
4609  // Construct MemoryBuffer and update buffer manager.
4610  PCMCache.addBuffer(OutputFile,
4611  llvm::MemoryBuffer::getMemBufferCopy(
4612  StringRef(Buffer.begin(), Buffer.size())));
4613  }
4614  return Signature;
4615 }
4616 
4617 template<typename Vector>
4618 static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec,
4619  ASTWriter::RecordData &Record) {
4620  for (typename Vector::iterator I = Vec.begin(nullptr, true), E = Vec.end();
4621  I != E; ++I) {
4622  Writer.AddDeclRef(*I, Record);
4623  }
4624 }
4625 
4626 ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
4627  const std::string &OutputFile,
4628  Module *WritingModule) {
4629  using namespace llvm;
4630 
4631  bool isModule = WritingModule != nullptr;
4632 
4633  // Make sure that the AST reader knows to finalize itself.
4634  if (Chain)
4635  Chain->finalizeForWriting();
4636 
4637  ASTContext &Context = SemaRef.Context;
4638  Preprocessor &PP = SemaRef.PP;
4639 
4640  // Set up predefined declaration IDs.
4641  auto RegisterPredefDecl = [&] (Decl *D, PredefinedDeclIDs ID) {
4642  if (D) {
4643  assert(D->isCanonicalDecl() && "predefined decl is not canonical");
4644  DeclIDs[D] = ID;
4645  }
4646  };
4647  RegisterPredefDecl(Context.getTranslationUnitDecl(),
4649  RegisterPredefDecl(Context.ObjCIdDecl, PREDEF_DECL_OBJC_ID_ID);
4650  RegisterPredefDecl(Context.ObjCSelDecl, PREDEF_DECL_OBJC_SEL_ID);
4651  RegisterPredefDecl(Context.ObjCClassDecl, PREDEF_DECL_OBJC_CLASS_ID);
4652  RegisterPredefDecl(Context.ObjCProtocolClassDecl,
4654  RegisterPredefDecl(Context.Int128Decl, PREDEF_DECL_INT_128_ID);
4655  RegisterPredefDecl(Context.UInt128Decl, PREDEF_DECL_UNSIGNED_INT_128_ID);
4656  RegisterPredefDecl(Context.ObjCInstanceTypeDecl,
4658  RegisterPredefDecl(Context.BuiltinVaListDecl, PREDEF_DECL_BUILTIN_VA_LIST_ID);
4659  RegisterPredefDecl(Context.VaListTagDecl, PREDEF_DECL_VA_LIST_TAG);
4660  RegisterPredefDecl(Context.BuiltinMSVaListDecl,
4662  RegisterPredefDecl(Context.ExternCContext, PREDEF_DECL_EXTERN_C_CONTEXT_ID);
4663  RegisterPredefDecl(Context.MakeIntegerSeqDecl,
4665  RegisterPredefDecl(Context.CFConstantStringTypeDecl,
4667  RegisterPredefDecl(Context.CFConstantStringTagDecl,
4669  RegisterPredefDecl(Context.TypePackElementDecl,
4671 
4672  // Build a record containing all of the tentative definitions in this file, in
4673  // TentativeDefinitions order. Generally, this record will be empty for
4674  // headers.
4675  RecordData TentativeDefinitions;
4676  AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
4677 
4678  // Build a record containing all of the file scoped decls in this file.
4679  RecordData UnusedFileScopedDecls;
4680  if (!isModule)
4682  UnusedFileScopedDecls);
4683 
4684  // Build a record containing all of the delegating constructors we still need
4685  // to resolve.
4686  RecordData DelegatingCtorDecls;
4687  if (!isModule)
4688  AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls);
4689 
4690  // Write the set of weak, undeclared identifiers. We always write the
4691  // entire table, since later PCH files in a PCH chain are only interested in
4692  // the results at the end of the chain.
4693  RecordData WeakUndeclaredIdentifiers;
4694  for (auto &WeakUndeclaredIdentifier : SemaRef.WeakUndeclaredIdentifiers) {
4695  IdentifierInfo *II = WeakUndeclaredIdentifier.first;
4696  WeakInfo &WI = WeakUndeclaredIdentifier.second;
4697  AddIdentifierRef(II, WeakUndeclaredIdentifiers);
4698  AddIdentifierRef(WI.getAlias(), WeakUndeclaredIdentifiers);
4699  AddSourceLocation(WI.getLocation(), WeakUndeclaredIdentifiers);
4700  WeakUndeclaredIdentifiers.push_back(WI.getUsed());
4701  }
4702 
4703  // Build a record containing all of the ext_vector declarations.
4704  RecordData ExtVectorDecls;
4705  AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls);
4706 
4707  // Build a record containing all of the VTable uses information.
4708  RecordData VTableUses;
4709  if (!SemaRef.VTableUses.empty()) {
4710  for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
4711  AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
4712  AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
4713  VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
4714  }
4715  }
4716 
4717  // Build a record containing all of the UnusedLocalTypedefNameCandidates.
4718  RecordData UnusedLocalTypedefNameCandidates;
4719  for (const TypedefNameDecl *TD : SemaRef.UnusedLocalTypedefNameCandidates)
4720  AddDeclRef(TD, UnusedLocalTypedefNameCandidates);
4721 
4722  // Build a record containing all of pending implicit instantiations.
4723  RecordData PendingInstantiations;
4724  for (const auto &I : SemaRef.PendingInstantiations) {
4725  AddDeclRef(I.first, PendingInstantiations);
4726  AddSourceLocation(I.second, PendingInstantiations);
4727  }
4728  assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
4729  "There are local ones at end of translation unit!");
4730 
4731  // Build a record containing some declaration references.
4732  RecordData SemaDeclRefs;
4733  if (SemaRef.StdNamespace || SemaRef.StdBadAlloc || SemaRef.StdAlignValT) {
4734  AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs);
4735  AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs);
4736  AddDeclRef(SemaRef.getStdAlignValT(), SemaDeclRefs);
4737  }
4738 
4739  RecordData CUDASpecialDeclRefs;
4740  if (Context.getcudaConfigureCallDecl()) {
4741  AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs);
4742  }
4743 
4744  // Build a record containing all of the known namespaces.
4745  RecordData KnownNamespaces;
4746  for (const auto &I : SemaRef.KnownNamespaces) {
4747  if (!I.second)
4748  AddDeclRef(I.first, KnownNamespaces);
4749  }
4750 
4751  // Build a record of all used, undefined objects that require definitions.
4752  RecordData UndefinedButUsed;
4753 
4755  SemaRef.getUndefinedButUsed(Undefined);
4756  for (const auto &I : Undefined) {
4757  AddDeclRef(I.first, UndefinedButUsed);
4758  AddSourceLocation(I.second, UndefinedButUsed);
4759  }
4760 
4761  // Build a record containing all delete-expressions that we would like to
4762  // analyze later in AST.
4763  RecordData DeleteExprsToAnalyze;
4764 
4765  for (const auto &DeleteExprsInfo :
4766  SemaRef.getMismatchingDeleteExpressions()) {
4767  AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze);
4768  DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());
4769  for (const auto &DeleteLoc : DeleteExprsInfo.second) {
4770  AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze);
4771  DeleteExprsToAnalyze.push_back(DeleteLoc.second);
4772  }
4773  }
4774 
4775  // Write the control block
4776  WriteControlBlock(PP, Context, isysroot, OutputFile);
4777 
4778  // Write the remaining AST contents.
4779  Stream.EnterSubblock(AST_BLOCK_ID, 5);
4780 
4781  // This is so that older clang versions, before the introduction
4782  // of the control block, can read and reject the newer PCH format.
4783  {
4784  RecordData Record = {VERSION_MAJOR};
4785  Stream.EmitRecord(METADATA_OLD_FORMAT, Record);
4786  }
4787 
4788  // Create a lexical update block containing all of the declarations in the
4789  // translation unit that do not come from other AST files.
4790  const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
4791  SmallVector<uint32_t, 128> NewGlobalKindDeclPairs;
4792  for (const auto *D : TU->noload_decls()) {
4793  if (!D->isFromASTFile()) {
4794  NewGlobalKindDeclPairs.push_back(D->getKind());
4795  NewGlobalKindDeclPairs.push_back(GetDeclRef(D));
4796  }
4797  }
4798 
4799  auto Abv = std::make_shared<BitCodeAbbrev>();
4800  Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
4801  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4802  unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
4803  {
4804  RecordData::value_type Record[] = {TU_UPDATE_LEXICAL};
4805  Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
4806  bytes(NewGlobalKindDeclPairs));
4807  }
4808 
4809  // And a visible updates block for the translation unit.
4810  Abv = std::make_shared<BitCodeAbbrev>();
4811  Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE));
4812  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4813  Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4814  UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));
4815  WriteDeclContextVisibleUpdate(TU);
4816 
4817  // If we have any extern "C" names, write out a visible update for them.
4818  if (Context.ExternCContext)
4819  WriteDeclContextVisibleUpdate(Context.ExternCContext);
4820 
4821  // If the translation unit has an anonymous namespace, and we don't already
4822  // have an update block for it, write it as an update block.
4823  // FIXME: Why do we not do this if there's already an update block?
4824  if (NamespaceDecl *NS = TU->getAnonymousNamespace()) {
4825  ASTWriter::UpdateRecord &Record = DeclUpdates[TU];
4826  if (Record.empty())
4827  Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS));
4828  }
4829 
4830  // Add update records for all mangling numbers and static local numbers.
4831  // These aren't really update records, but this is a convenient way of
4832  // tagging this rare extra data onto the declarations.
4833  for (const auto &Number : Context.MangleNumbers)
4834  if (!Number.first->isFromASTFile())
4835  DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER,
4836  Number.second));
4837  for (const auto &Number : Context.StaticLocalNumbers)
4838  if (!Number.first->isFromASTFile())
4839  DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER,
4840  Number.second));
4841 
4842  // Make sure visible decls, added to DeclContexts previously loaded from
4843  // an AST file, are registered for serialization. Likewise for template
4844  // specializations added to imported templates.
4845  for (const auto *I : DeclsToEmitEvenIfUnreferenced) {
4846  GetDeclRef(I);
4847  }
4848 
4849  // Make sure all decls associated with an identifier are registered for
4850  // serialization, if we're storing decls with identifiers.
4851  if (!WritingModule || !getLangOpts().CPlusPlus) {
4853  for (const auto &ID : PP.getIdentifierTable()) {
4854  const IdentifierInfo *II = ID.second;
4855  if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization())
4856  IIs.push_back(II);
4857  }
4858  // Sort the identifiers to visit based on their name.
4859  llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
4860  for (const IdentifierInfo *II : IIs) {
4861  for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II),
4862  DEnd = SemaRef.IdResolver.end();
4863  D != DEnd; ++D) {
4864  GetDeclRef(*D);
4865  }
4866  }
4867  }
4868 
4869  // For method pool in the module, if it contains an entry for a selector,
4870  // the entry should be complete, containing everything introduced by that
4871  // module and all modules it imports. It's possible that the entry is out of
4872  // date, so we need to pull in the new content here.
4873 
4874  // It's possible that updateOutOfDateSelector can update SelectorIDs. To be
4875  // safe, we copy all selectors out.
4876  llvm::SmallVector<Selector, 256> AllSelectors;
4877  for (auto &SelectorAndID : SelectorIDs)
4878  AllSelectors.push_back(SelectorAndID.first);
4879  for (auto &Selector : AllSelectors)
4881 
4882  // Form the record of special types.
4883  RecordData SpecialTypes;
4884  AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes);
4885  AddTypeRef(Context.getFILEType(), SpecialTypes);
4886  AddTypeRef(Context.getjmp_bufType(), SpecialTypes);
4887  AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes);
4888  AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
4889  AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
4890  AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
4891  AddTypeRef(Context.getucontext_tType(), SpecialTypes);
4892 
4893  if (Chain) {
4894  // Write the mapping information describing our module dependencies and how
4895  // each of those modules were mapped into our own offset/ID space, so that
4896  // the reader can build the appropriate mapping to its own offset/ID space.
4897  // The map consists solely of a blob with the following format:
4898  // *(module-kind:i8
4899  // module-name-len:i16 module-name:len*i8
4900  // source-location-offset:i32
4901  // identifier-id:i32
4902  // preprocessed-entity-id:i32
4903  // macro-definition-id:i32
4904  // submodule-id:i32
4905  // selector-id:i32
4906  // declaration-id:i32
4907  // c++-base-specifiers-id:i32
4908  // type-id:i32)
4909  //
4910  // module-kind is the ModuleKind enum value. If it is MK_PrebuiltModule or
4911  // MK_ExplicitModule, then the module-name is the module name. Otherwise,
4912  // it is the module file name.
4913  auto Abbrev = std::make_shared<BitCodeAbbrev>();
4914  Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
4915  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4916  unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
4917  SmallString<2048> Buffer;
4918  {
4919  llvm::raw_svector_ostream Out(Buffer);
4920  for (ModuleFile &M : Chain->ModuleMgr) {
4921  using namespace llvm::support;
4922 
4923  endian::Writer LE(Out, little);
4924  LE.write<uint8_t>(static_cast<uint8_t>(M.Kind));
4925  StringRef Name =
4927  ? M.ModuleName
4928  : M.FileName;
4929  LE.write<uint16_t>(Name.size());
4930  Out.write(Name.data(), Name.size());
4931 
4932  // Note: if a base ID was uint max, it would not be possible to load
4933  // another module after it or have more than one entity inside it.
4935 
4936  auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) {
4937  assert(BaseID < std::numeric_limits<uint32_t>::max() && "base id too high");
4938  if (ShouldWrite)
4939  LE.write<uint32_t>(BaseID);
4940  else
4941  LE.write<uint32_t>(None);
4942  };
4943 
4944  // These values should be unique within a chain, since they will be read
4945  // as keys into ContinuousRangeMaps.
4946  writeBaseIDOrNone(M.SLocEntryBaseOffset, M.LocalNumSLocEntries);
4947  writeBaseIDOrNone(M.BaseIdentifierID, M.LocalNumIdentifiers);
4948  writeBaseIDOrNone(M.BaseMacroID, M.LocalNumMacros);
4949  writeBaseIDOrNone(M.BasePreprocessedEntityID,
4951  writeBaseIDOrNone(M.BaseSubmoduleID, M.LocalNumSubmodules);
4952  writeBaseIDOrNone(M.BaseSelectorID, M.LocalNumSelectors);
4953  writeBaseIDOrNone(M.BaseDeclID, M.LocalNumDecls);
4954  writeBaseIDOrNone(M.BaseTypeIndex, M.LocalNumTypes);
4955  }
4956  }
4957  RecordData::value_type Record[] = {MODULE_OFFSET_MAP};
4958  Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
4959  Buffer.data(), Buffer.size());
4960  }
4961 
4962  RecordData DeclUpdatesOffsetsRecord;
4963 
4964  // Keep writing types, declarations, and declaration update records
4965  // until we've emitted all of them.
4966  Stream.EnterSubblock(DECLTYPES_BLOCK_ID, /*bits for abbreviations*/5);
4967  WriteTypeAbbrevs();
4968  WriteDeclAbbrevs();
4969  do {
4970  WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord);
4971  while (!DeclTypesToEmit.empty()) {
4972  DeclOrType DOT = DeclTypesToEmit.front();
4973  DeclTypesToEmit.pop();
4974  if (DOT.isType())
4975  WriteType(DOT.getType());
4976  else
4977  WriteDecl(Context, DOT.getDecl());
4978  }
4979  } while (!DeclUpdates.empty());
4980  Stream.ExitBlock();
4981 
4982  DoneWritingDeclsAndTypes = true;
4983 
4984  // These things can only be done once we've written out decls and types.
4985  WriteTypeDeclOffsets();
4986  if (!DeclUpdatesOffsetsRecord.empty())
4987  Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord);
4988  WriteFileDeclIDsMap();
4989  WriteSourceManagerBlock(Context.getSourceManager(), PP);
4990  WriteComments();
4991  WritePreprocessor(PP, isModule);
4992  WriteHeaderSearch(PP.getHeaderSearchInfo());
4993  WriteSelectors(SemaRef);
4994  WriteReferencedSelectorsPool(SemaRef);
4995  WriteLateParsedTemplates(SemaRef);
4996  WriteIdentifierTable(PP, SemaRef.IdResolver, isModule);
4997  WriteFPPragmaOptions(SemaRef.getFPOptions());
4998  WriteOpenCLExtensions(SemaRef);
4999  WriteOpenCLExtensionTypes(SemaRef);
5000  WriteOpenCLExtensionDecls(SemaRef);
5001  WriteCUDAPragmas(SemaRef);
5002 
5003  // If we're emitting a module, write out the submodule information.
5004  if (WritingModule)
5005  WriteSubmodules(WritingModule);
5006 
5007  Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes);
5008 
5009  // Write the record containing external, unnamed definitions.
5010  if (!EagerlyDeserializedDecls.empty())
5011  Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls);
5012 
5013  if (!ModularCodegenDecls.empty())
5014  Stream.EmitRecord(MODULAR_CODEGEN_DECLS, ModularCodegenDecls);
5015 
5016  // Write the record containing tentative definitions.
5017  if (!TentativeDefinitions.empty())
5018  Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
5019 
5020  // Write the record containing unused file scoped decls.
5021  if (!UnusedFileScopedDecls.empty())
5022  Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
5023 
5024  // Write the record containing weak undeclared identifiers.
5025  if (!WeakUndeclaredIdentifiers.empty())
5026  Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
5027  WeakUndeclaredIdentifiers);
5028 
5029  // Write the record containing ext_vector type names.
5030  if (!ExtVectorDecls.empty())
5031  Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
5032 
5033  // Write the record containing VTable uses information.
5034  if (!VTableUses.empty())
5035  Stream.EmitRecord(VTABLE_USES, VTableUses);
5036 
5037  // Write the record containing potentially unused local typedefs.
5038  if (!UnusedLocalTypedefNameCandidates.empty())
5039  Stream.EmitRecord(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES,
5040  UnusedLocalTypedefNameCandidates);
5041 
5042  // Write the record containing pending implicit instantiations.
5043  if (!PendingInstantiations.empty())
5044  Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
5045 
5046  // Write the record containing declaration references of Sema.
5047  if (!SemaDeclRefs.empty())
5048  Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
5049 
5050  // Write the record containing CUDA-specific declaration references.
5051  if (!CUDASpecialDeclRefs.empty())
5052  Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs);
5053 
5054  // Write the delegating constructors.
5055  if (!DelegatingCtorDecls.empty())
5056  Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls);
5057 
5058  // Write the known namespaces.
5059  if (!KnownNamespaces.empty())
5060  Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces);
5061 
5062  // Write the undefined internal functions and variables, and inline functions.
5063  if (!UndefinedButUsed.empty())
5064  Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed);
5065 
5066  if (!DeleteExprsToAnalyze.empty())
5067  Stream.EmitRecord(DELETE_EXPRS_TO_ANALYZE, DeleteExprsToAnalyze);
5068 
5069  // Write the visible updates to DeclContexts.
5070  for (auto *DC : UpdatedDeclContexts)
5071  WriteDeclContextVisibleUpdate(DC);
5072 
5073  if (!WritingModule) {
5074  // Write the submodules that were imported, if any.
5075  struct ModuleInfo {
5076  uint64_t ID;
5077  Module *M;
5078  ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {}
5079  };
5081  for (const auto *I : Context.local_imports()) {
5082  assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end());
5083  Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
5084  I->getImportedModule()));
5085  }
5086 
5087  if (!Imports.empty()) {
5088  auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) {
5089  return A.ID < B.ID;
5090  };
5091  auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) {
5092  return A.ID == B.ID;
5093  };
5094 
5095  // Sort and deduplicate module IDs.
5096  llvm::sort(Imports.begin(), Imports.end(), Cmp);
5097  Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq),
5098  Imports.end());
5099 
5100  RecordData ImportedModules;
5101  for (const auto &Import : Imports) {
5102  ImportedModules.push_back(Import.ID);
5103  // FIXME: If the module has macros imported then later has declarations
5104  // imported, this location won't be the right one as a location for the
5105  // declaration imports.
5106  AddSourceLocation(PP.getModuleImportLoc(Import.M), ImportedModules);
5107  }
5108 
5109  Stream.EmitRecord(IMPORTED_MODULES, ImportedModules);
5110  }
5111  }
5112 
5113  WriteObjCCategories();
5114  if(!WritingModule) {
5115  WriteOptimizePragmaOptions(SemaRef);
5116  WriteMSStructPragmaOptions(SemaRef);
5117  WriteMSPointersToMembersPragmaOptions(SemaRef);
5118  }
5119  WritePackPragmaOptions(SemaRef);
5120 
5121  // Some simple statistics
5122  RecordData::value_type Record[] = {
5123  NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts};
5124  Stream.EmitRecord(STATISTICS, Record);
5125  Stream.ExitBlock();
5126 
5127  // Write the module file extension blocks.
5128  for (const auto &ExtWriter : ModuleFileExtensionWriters)
5129  WriteModuleFileExtension(SemaRef, *ExtWriter);
5130 
5131  return writeUnhashedControlBlock(PP, Context);
5132 }
5133 
5134 void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
5135  if (DeclUpdates.empty())
5136  return;
5137 
5138  DeclUpdateMap LocalUpdates;
5139  LocalUpdates.swap(DeclUpdates);
5140 
5141  for (auto &DeclUpdate : LocalUpdates) {
5142  const Decl *D = DeclUpdate.first;
5143 
5144  bool HasUpdatedBody = false;
5146  ASTRecordWriter Record(*this, RecordData);
5147  for (auto &Update : DeclUpdate.second) {
5149 
5150  // An updated body is emitted last, so that the reader doesn't need
5151  // to skip over the lazy body to reach statements for other records.
5153  HasUpdatedBody = true;
5154  else
5155  Record.push_back(Kind);
5156 
5157  switch (Kind) {
5161  assert(Update.getDecl() && "no decl to add?");
5162  Record.push_back(GetDeclRef(Update.getDecl()));
5163  break;
5164 
5166  break;
5167 
5169  // FIXME: Do we need to also save the template specialization kind here?
5170  Record.AddSourceLocation(Update.getLoc());
5171  break;
5172 
5174  const VarDecl *VD = cast<VarDecl>(D);
5175  Record.push_back(VD->isInline());
5176  Record.push_back(VD->isInlineSpecified());
5177  if (VD->getInit()) {
5178  Record.push_back(!VD->isInitKnownICE() ? 1
5179  : (VD->isInitICE() ? 3 : 2));
5180  Record.AddStmt(const_cast<Expr*>(VD->getInit()));
5181  } else {
5182  Record.push_back(0);
5183  }
5184  break;
5185  }
5186 
5188  Record.AddStmt(const_cast<Expr *>(
5189  cast<ParmVarDecl>(Update.getDecl())->getDefaultArg()));
5190  break;
5191 
5193  Record.AddStmt(
5194  cast<FieldDecl>(Update.getDecl())->getInClassInitializer());
5195  break;
5196 
5198  auto *RD = cast<CXXRecordDecl>(D);
5199  UpdatedDeclContexts.insert(RD->getPrimaryContext());
5200  Record.push_back(RD->isParamDestroyedInCallee());
5201  Record.push_back(RD->getArgPassingRestrictions());
5202  Record.AddCXXDefinitionData(RD);
5203  Record.AddOffset(WriteDeclContextLexicalBlock(
5204  *Context, const_cast<CXXRecordDecl *>(RD)));
5205 
5206  // This state is sometimes updated by template instantiation, when we
5207  // switch from the specialization referring to the template declaration
5208  // to it referring to the template definition.
5209  if (auto *MSInfo = RD->getMemberSpecializationInfo()) {
5210  Record.push_back(MSInfo->getTemplateSpecializationKind());
5211  Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
5212  } else {
5213  auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
5214  Record.push_back(Spec->getTemplateSpecializationKind());
5215  Record.AddSourceLocation(Spec->getPointOfInstantiation());
5216 
5217  // The instantiation might have been resolved to a partial
5218  // specialization. If so, record which one.
5219  auto From = Spec->getInstantiatedFrom();
5220  if (auto PartialSpec =
5221  From.dyn_cast<ClassTemplatePartialSpecializationDecl*>()) {
5222  Record.push_back(true);
5223  Record.AddDeclRef(PartialSpec);
5224  Record.AddTemplateArgumentList(
5225  &Spec->getTemplateInstantiationArgs());
5226  } else {
5227  Record.push_back(false);
5228  }
5229  }
5230  Record.push_back(RD->getTagKind());
5231  Record.AddSourceLocation(RD->getLocation());
5232  Record.AddSourceLocation(RD->getLocStart());
5233  Record.AddSourceRange(RD->getBraceRange());
5234 
5235  // Instantiation may change attributes; write them all out afresh.
5236  Record.push_back(D->hasAttrs());
5237  if (D->hasAttrs())
5238  Record.AddAttributes(D->getAttrs());
5239 
5240  // FIXME: Ensure we don't get here for explicit instantiations.
5241  break;
5242  }
5243 
5245  Record.AddDeclRef(Update.getDecl());
5246  Record.AddStmt(cast<CXXDestructorDecl>(D)->getOperatorDeleteThisArg());
5247  break;
5248 
5251  cast<FunctionDecl>(D)->getType()->castAs<FunctionProtoType>(),
5252  Record);
5253  break;
5254 
5256  Record.push_back(GetOrCreateTypeID(Update.getType()));
5257  break;
5258 
5259  case UPD_DECL_MARKED_USED:
5260  break;
5261 
5262  case UPD_MANGLING_NUMBER:
5264  Record.push_back(Update.getNumber());
5265  break;
5266 
5268  Record.AddSourceRange(
5269  D->getAttr<OMPThreadPrivateDeclAttr>()->getRange());
5270  break;
5271 
5273  Record.AddSourceRange(
5274  D->getAttr<OMPDeclareTargetDeclAttr>()->getRange());
5275  break;
5276 
5277  case UPD_DECL_EXPORTED:
5278  Record.push_back(getSubmoduleID(Update.getModule()));
5279  break;
5280 
5282  Record.AddAttributes(llvm::makeArrayRef(Update.getAttr()));
5283  break;
5284  }
5285  }
5286 
5287  if (HasUpdatedBody) {
5288  const auto *Def = cast<FunctionDecl>(D);
5290  Record.push_back(Def->isInlined());
5291  Record.AddSourceLocation(Def->getInnerLocStart());
5292  Record.AddFunctionDefinition(Def);
5293  }
5294 
5295  OffsetsRecord.push_back(GetDeclRef(D));
5296  OffsetsRecord.push_back(Record.Emit(DECL_UPDATES));
5297  }
5298 }
5299 
5301  uint32_t Raw = Loc.getRawEncoding();
5302  Record.push_back((Raw << 1) | (Raw >> 31));
5303 }
5304 
5306  AddSourceLocation(Range.getBegin(), Record);
5307  AddSourceLocation(Range.getEnd(), Record);
5308 }
5309 
5310 void ASTRecordWriter::AddAPInt(const llvm::APInt &Value) {
5311  Record->push_back(Value.getBitWidth());
5312  const uint64_t *Words = Value.getRawData();
5313  Record->append(Words, Words + Value.getNumWords());
5314 }
5315 
5316 void ASTRecordWriter::AddAPSInt(const llvm::APSInt &Value) {
5317  Record->push_back(Value.isUnsigned());
5318  AddAPInt(Value);
5319 }
5320 
5321 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) {
5322  AddAPInt(Value.bitcastToAPInt());
5323 }
5324 
5326  Record.push_back(getIdentifierRef(II));
5327 }
5328 
5330  if (!II)
5331  return 0;
5332 
5333  IdentID &ID = IdentifierIDs[II];
5334  if (ID == 0)
5335  ID = NextIdentID++;
5336  return ID;
5337 }
5338 
5340  // Don't emit builtin macros like __LINE__ to the AST file unless they
5341  // have been redefined by the header (in which case they are not
5342  // isBuiltinMacro).
5343  if (!MI || MI->isBuiltinMacro())
5344  return 0;
5345 
5346  MacroID &ID = MacroIDs[MI];
5347  if (ID == 0) {
5348  ID = NextMacroID++;
5349  MacroInfoToEmitData Info = { Name, MI, ID };
5350  MacroInfosToEmit.push_back(Info);
5351  }
5352  return ID;
5353 }
5354 
5356  if (!MI || MI->isBuiltinMacro())
5357  return 0;
5358 
5359  assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!");
5360  return MacroIDs[MI];
5361 }
5362 
5364  return IdentMacroDirectivesOffsetMap.lookup(Name);
5365 }
5366 
5368  Record->push_back(Writer->getSelectorRef(SelRef));
5369 }
5370 
5372  if (Sel.getAsOpaquePtr() == nullptr) {
5373  return 0;
5374  }
5375 
5376  SelectorID SID = SelectorIDs[Sel];
5377  if (SID == 0 && Chain) {
5378  // This might trigger a ReadSelector callback, which will set the ID for
5379  // this selector.
5380  Chain->LoadSelector(Sel);
5381  SID = SelectorIDs[Sel];
5382  }
5383  if (SID == 0) {
5384  SID = NextSelectorID++;
5385  SelectorIDs[Sel] = SID;
5386  }
5387  return SID;
5388 }
5389 
5391  AddDeclRef(Temp->getDestructor());
5392 }
5393 
5396  switch (Kind) {
5398  AddStmt(Arg.getAsExpr());
5399  break;
5401  AddTypeSourceInfo(Arg.getAsTypeSourceInfo());
5402  break;
5404  AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc());
5406  break;
5408  AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc());
5411  break;
5417  // FIXME: Is this right?
5418  break;
5419  }
5420 }
5421 
5423  AddTemplateArgument(Arg.getArgument());
5424 
5426  bool InfoHasSameExpr
5427  = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
5428  Record->push_back(InfoHasSameExpr);
5429  if (InfoHasSameExpr)
5430  return; // Avoid storing the same expr twice.
5431  }
5432  AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo());
5433 }
5434 
5436  if (!TInfo) {
5437  AddTypeRef(QualType());
5438  return;
5439  }
5440 
5441  AddTypeLoc(TInfo->getTypeLoc());
5442 }
5443 
5445  AddTypeRef(TL.getType());
5446 
5447  TypeLocWriter TLW(*this);
5448  for (; !TL.isNull(); TL = TL.getNextTypeLoc())
5449  TLW.Visit(TL);
5450 }
5451 
5453  Record.push_back(GetOrCreateTypeID(T));
5454 }
5455 
5457  assert(Context);
5458  return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx {
5459  if (T.isNull())
5460  return TypeIdx();
5461  assert(!T.getLocalFastQualifiers());
5462 
5463  TypeIdx &Idx = TypeIdxs[T];
5464  if (Idx.getIndex() == 0) {
5465  if (DoneWritingDeclsAndTypes) {
5466  assert(0 && "New type seen after serializing all the types to emit!");
5467  return TypeIdx();
5468  }
5469 
5470  // We haven't seen this type before. Assign it a new ID and put it
5471  // into the queue of types to emit.
5472  Idx = TypeIdx(NextTypeID++);
5473  DeclTypesToEmit.push(T);
5474  }
5475  return Idx;
5476  });
5477 }
5478 
5480  assert(Context);
5481  return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx {
5482  if (T.isNull())
5483  return TypeIdx();
5484  assert(!T.getLocalFastQualifiers());
5485 
5486  TypeIdxMap::const_iterator I = TypeIdxs.find(T);
5487  assert(I != TypeIdxs.end() && "Type not emitted!");
5488  return I->second;
5489  });
5490 }
5491 
5492 void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) {
5493  Record.push_back(GetDeclRef(D));
5494 }
5495 
5497  assert(WritingAST && "Cannot request a declaration ID before AST writing");
5498 
5499  if (!D) {
5500  return 0;
5501  }
5502 
5503  // If D comes from an AST file, its declaration ID is already known and
5504  // fixed.
5505  if (D->isFromASTFile())
5506  return D->getGlobalID();
5507 
5508  assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer");
5509  DeclID &ID = DeclIDs[D];
5510  if (ID == 0) {
5511  if (DoneWritingDeclsAndTypes) {
5512  assert(0 && "New decl seen after serializing all the decls to emit!");
5513  return 0;
5514  }
5515 
5516  // We haven't seen this declaration before. Give it a new ID and
5517  // enqueue it in the list of declarations to emit.
5518  ID = NextDeclID++;
5519  DeclTypesToEmit.push(const_cast<Decl *>(D));
5520  }
5521 
5522  return ID;
5523 }
5524 
5526  if (!D)
5527  return 0;
5528 
5529  // If D comes from an AST file, its declaration ID is already known and
5530  // fixed.
5531  if (D->isFromASTFile())
5532  return D->getGlobalID();
5533 
5534  assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
5535  return DeclIDs[D];
5536 }
5537 
5538 void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) {
5539  assert(ID);
5540  assert(D);
5541 
5542  SourceLocation Loc = D->getLocation();
5543  if (Loc.isInvalid())
5544  return;
5545 
5546  // We only keep track of the file-level declarations of each file.
5547  if (!D->getLexicalDeclContext()->isFileContext())
5548  return;
5549  // FIXME: ParmVarDecls that are part of a function type of a parameter of
5550  // a function/objc method, should not have TU as lexical context.
5551  // TemplateTemplateParmDecls that are part of an alias template, should not
5552  // have TU as lexical context.
5553  if (isa<ParmVarDecl>(D) || isa<TemplateTemplateParmDecl>(D))
5554  return;
5555 
5556  SourceManager &SM = Context->getSourceManager();
5557  SourceLocation FileLoc = SM.getFileLoc(Loc);
5558  assert(SM.isLocalSourceLocation(FileLoc));
5559  FileID FID;
5560  unsigned Offset;
5561  std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
5562  if (FID.isInvalid())
5563  return;
5564  assert(SM.getSLocEntry(FID).isFile());
5565 
5566  DeclIDInFileInfo *&Info = FileDeclIDs[FID];
5567  if (!Info)
5568  Info = new DeclIDInFileInfo();
5569 
5570  std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID);
5571  LocDeclIDsTy &Decls = Info->DeclIDs;
5572 
5573  if (Decls.empty() || Decls.back().first <= Offset) {
5574  Decls.push_back(LocDecl);
5575  return;
5576  }
5577 
5578  LocDeclIDsTy::iterator I =
5579  std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first());
5580 
5581  Decls.insert(I, LocDecl);
5582 }
5583 
5585  // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc.
5586  Record->push_back(Name.getNameKind());
5587  switch (Name.getNameKind()) {
5590  break;
5591 
5595  AddSelectorRef(Name.getObjCSelector());
5596  break;
5597 
5601  AddTypeRef(Name.getCXXNameType());
5602  break;
5603 
5606  break;
5607 
5609  Record->push_back(Name.getCXXOverloadedOperator());
5610  break;
5611 
5614  break;
5615 
5617  // No extra data to emit
5618  break;
5619  }
5620 }
5621 
5623  assert(needsAnonymousDeclarationNumber(D) &&
5624  "expected an anonymous declaration");
5625 
5626  // Number the anonymous declarations within this context, if we've not
5627  // already done so.
5628  auto It = AnonymousDeclarationNumbers.find(D);
5629  if (It == AnonymousDeclarationNumbers.end()) {
5630  auto *DC = D->getLexicalDeclContext();
5631  numberAnonymousDeclsWithin(DC, [&](const NamedDecl *ND, unsigned Number) {
5632  AnonymousDeclarationNumbers[ND] = Number;
5633  });
5634 
5635  It = AnonymousDeclarationNumbers.find(D);
5636  assert(It != AnonymousDeclarationNumbers.end() &&
5637  "declaration not found within its lexical context");
5638  }
5639 
5640  return It->second;
5641 }
5642 
5644  DeclarationName Name) {
5645  switch (Name.getNameKind()) {
5649  AddTypeSourceInfo(DNLoc.NamedType.TInfo);
5650  break;
5651 
5657  break;
5658 
5662  break;
5663 
5670  break;
5671  }
5672 }
5673 
5675  const DeclarationNameInfo &NameInfo) {
5676  AddDeclarationName(NameInfo.getName());
5677  AddSourceLocation(NameInfo.getLoc());
5678  AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName());
5679 }
5680 
5682  AddNestedNameSpecifierLoc(Info.QualifierLoc);
5683  Record->push_back(Info.NumTemplParamLists);
5684  for (unsigned i = 0, e = Info.NumTemplParamLists; i != e; ++i)
5685  AddTemplateParameterList(Info.TemplParamLists[i]);
5686 }
5687 
5689  // Nested name specifiers usually aren't too long. I think that 8 would
5690  // typically accommodate the vast majority.
5692 
5693  // Push each of the NNS's onto a stack for serialization in reverse order.
5694  while (NNS) {
5695  NestedNames.push_back(NNS);
5696  NNS = NNS->getPrefix();
5697  }
5698 
5699  Record->push_back(NestedNames.size());
5700  while(!NestedNames.empty()) {
5701  NNS = NestedNames.pop_back_val();
5703  Record->push_back(Kind);
5704  switch (Kind) {
5707  break;
5708 
5710  AddDeclRef(NNS->getAsNamespace());
5711  break;
5712 
5715  break;
5716 
5719  AddTypeRef(QualType(NNS->getAsType(), 0));
5720  Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
5721  break;
5722 
5724  // Don't need to write an associated value.
5725  break;
5726 
5728  AddDeclRef(NNS->getAsRecordDecl());
5729  break;
5730  }
5731  }
5732 }
5733