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