blob: d770f8df26ed9e9b8e858bfd0e0e83e16edc5001 [file] [log] [blame]
Sebastian Redld6522cf2010-08-18 23:56:31 +00001//===--- ASTWriter.cpp - AST File Writer ----------------------------------===//
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
Sebastian Redl55c0ad52010-08-18 23:56:21 +000010// This file defines the ASTWriter class, which writes AST files.
Douglas Gregoref84c4b2009-04-09 22:27:44 +000011//
12//===----------------------------------------------------------------------===//
13
Sebastian Redl1914c6f2010-08-18 23:56:37 +000014#include "clang/Serialization/ASTWriter.h"
Argyrios Kyrtzidis4bd97102010-08-20 16:03:52 +000015#include "ASTCommon.h"
Douglas Gregoref84c4b2009-04-09 22:27:44 +000016#include "clang/AST/ASTContext.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclContextInternals.h"
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +000019#include "clang/AST/DeclFriend.h"
Richard Smith961eae52014-03-25 01:14:22 +000020#include "clang/AST/DeclLookups.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000021#include "clang/AST/DeclTemplate.h"
Douglas Gregorfeb84b02009-04-14 21:18:50 +000022#include "clang/AST/Expr.h"
John McCallbfd822c2010-08-24 07:32:53 +000023#include "clang/AST/ExprCXX.h"
Douglas Gregoref84c4b2009-04-09 22:27:44 +000024#include "clang/AST/Type.h"
John McCall8f115c62009-10-16 21:56:05 +000025#include "clang/AST/TypeLocVisitor.h"
Douglas Gregora7f71a92009-04-10 03:52:48 +000026#include "clang/Basic/FileManager.h"
Chris Lattner226efd32010-11-23 19:19:34 +000027#include "clang/Basic/FileSystemStatCache.h"
Douglas Gregora7f71a92009-04-10 03:52:48 +000028#include "clang/Basic/SourceManager.h"
Douglas Gregor4c7626e2009-04-13 16:31:14 +000029#include "clang/Basic/SourceManagerInternals.h"
Douglas Gregorbfbde532009-04-10 21:16:55 +000030#include "clang/Basic/TargetInfo.h"
Douglas Gregorcb177f12012-10-16 23:40:58 +000031#include "clang/Basic/TargetOptions.h"
Douglas Gregor7b71e632009-04-27 22:23:34 +000032#include "clang/Basic/Version.h"
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000033#include "clang/Basic/VersionTuple.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000034#include "clang/Lex/HeaderSearch.h"
35#include "clang/Lex/HeaderSearchOptions.h"
36#include "clang/Lex/MacroInfo.h"
37#include "clang/Lex/PreprocessingRecord.h"
38#include "clang/Lex/Preprocessor.h"
39#include "clang/Lex/PreprocessorOptions.h"
40#include "clang/Sema/IdentifierResolver.h"
41#include "clang/Sema/Sema.h"
42#include "clang/Serialization/ASTReader.h"
Douglas Gregore0a3a512009-04-14 21:55:33 +000043#include "llvm/ADT/APFloat.h"
44#include "llvm/ADT/APInt.h"
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +000045#include "llvm/ADT/Hashing.h"
Daniel Dunbarf8502d52009-10-17 23:52:28 +000046#include "llvm/ADT/StringExtras.h"
Douglas Gregoref84c4b2009-04-09 22:27:44 +000047#include "llvm/Bitcode/BitstreamWriter.h"
Justin Bognere1c147c2014-03-28 22:03:19 +000048#include "llvm/Support/EndianStream.h"
Michael J. Spencer740857f2010-12-21 16:45:57 +000049#include "llvm/Support/FileSystem.h"
Douglas Gregora7f71a92009-04-10 03:52:48 +000050#include "llvm/Support/MemoryBuffer.h"
Justin Bognerbb094f02014-04-18 19:57:06 +000051#include "llvm/Support/OnDiskHashTable.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000052#include "llvm/Support/Path.h"
Douglas Gregor925296b2011-07-19 16:10:42 +000053#include <algorithm>
Chris Lattner225dd6c2009-04-11 18:40:46 +000054#include <cstdio>
Douglas Gregor09b69892011-02-10 17:09:37 +000055#include <string.h>
Douglas Gregor925296b2011-07-19 16:10:42 +000056#include <utility>
Douglas Gregoref84c4b2009-04-09 22:27:44 +000057using namespace clang;
Sebastian Redl539c5062010-08-18 23:57:32 +000058using namespace clang::serialization;
Douglas Gregoref84c4b2009-04-09 22:27:44 +000059
Sebastian Redl3df5a082010-07-30 17:03:48 +000060template <typename T, typename Allocator>
Chris Lattner0e62c1c2011-07-23 10:55:15 +000061static StringRef data(const std::vector<T, Allocator> &v) {
62 if (v.empty()) return StringRef();
63 return StringRef(reinterpret_cast<const char*>(&v[0]),
Benjamin Kramerd47a12a2011-04-24 17:44:50 +000064 sizeof(T) * v.size());
Sebastian Redl3df5a082010-07-30 17:03:48 +000065}
Benjamin Kramerd47a12a2011-04-24 17:44:50 +000066
67template <typename T>
Chris Lattner0e62c1c2011-07-23 10:55:15 +000068static StringRef data(const SmallVectorImpl<T> &v) {
69 return StringRef(reinterpret_cast<const char*>(v.data()),
Benjamin Kramerd47a12a2011-04-24 17:44:50 +000070 sizeof(T) * v.size());
Sebastian Redl3df5a082010-07-30 17:03:48 +000071}
72
Douglas Gregoref84c4b2009-04-09 22:27:44 +000073//===----------------------------------------------------------------------===//
74// Type serialization
75//===----------------------------------------------------------------------===//
Chris Lattner7099dbc2009-04-27 06:16:06 +000076
Douglas Gregoref84c4b2009-04-09 22:27:44 +000077namespace {
Sebastian Redl42a0f6a2010-08-18 23:56:27 +000078 class ASTTypeWriter {
Sebastian Redl55c0ad52010-08-18 23:56:21 +000079 ASTWriter &Writer;
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +000080 ASTWriter::RecordDataImpl &Record;
Douglas Gregoref84c4b2009-04-09 22:27:44 +000081
82 public:
83 /// \brief Type code that corresponds to the record generated.
Sebastian Redl539c5062010-08-18 23:57:32 +000084 TypeCode Code;
Douglas Gregoref84c4b2009-04-09 22:27:44 +000085
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +000086 ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
Sebastian Redl539c5062010-08-18 23:57:32 +000087 : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { }
Douglas Gregoref84c4b2009-04-09 22:27:44 +000088
89 void VisitArrayType(const ArrayType *T);
90 void VisitFunctionType(const FunctionType *T);
91 void VisitTagType(const TagType *T);
92
93#define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T);
94#define ABSTRACT_TYPE(Class, Base)
Douglas Gregoref84c4b2009-04-09 22:27:44 +000095#include "clang/AST/TypeNodes.def"
96 };
97}
98
Sebastian Redl42a0f6a2010-08-18 23:56:27 +000099void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {
David Blaikie83d382b2011-09-23 05:06:16 +0000100 llvm_unreachable("Built-in types are never serialized");
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000101}
102
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000103void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000104 Writer.AddTypeRef(T->getElementType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000105 Code = TYPE_COMPLEX;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000106}
107
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000108void ASTTypeWriter::VisitPointerType(const PointerType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000109 Writer.AddTypeRef(T->getPointeeType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000110 Code = TYPE_POINTER;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000111}
112
Reid Kleckner8a365022013-06-24 17:51:48 +0000113void ASTTypeWriter::VisitDecayedType(const DecayedType *T) {
114 Writer.AddTypeRef(T->getOriginalType(), Record);
115 Code = TYPE_DECAYED;
116}
117
Reid Kleckner0503a872013-12-05 01:23:43 +0000118void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) {
119 Writer.AddTypeRef(T->getOriginalType(), Record);
120 Writer.AddTypeRef(T->getAdjustedType(), Record);
121 Code = TYPE_ADJUSTED;
122}
123
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000124void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
Mike Stump11289f42009-09-09 15:08:12 +0000125 Writer.AddTypeRef(T->getPointeeType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000126 Code = TYPE_BLOCK_POINTER;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000127}
128
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000129void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
Richard Smith0f538462011-04-12 10:38:03 +0000130 Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
131 Record.push_back(T->isSpelledAsLValue());
Sebastian Redl539c5062010-08-18 23:57:32 +0000132 Code = TYPE_LVALUE_REFERENCE;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000133}
134
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000135void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) {
Richard Smith0f538462011-04-12 10:38:03 +0000136 Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000137 Code = TYPE_RVALUE_REFERENCE;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000138}
139
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000140void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) {
Mike Stump11289f42009-09-09 15:08:12 +0000141 Writer.AddTypeRef(T->getPointeeType(), Record);
142 Writer.AddTypeRef(QualType(T->getClass(), 0), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000143 Code = TYPE_MEMBER_POINTER;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000144}
145
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000146void ASTTypeWriter::VisitArrayType(const ArrayType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000147 Writer.AddTypeRef(T->getElementType(), Record);
148 Record.push_back(T->getSizeModifier()); // FIXME: stable values
John McCall8ccfcb52009-09-24 19:53:00 +0000149 Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000150}
151
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000152void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000153 VisitArrayType(T);
154 Writer.AddAPInt(T->getSize(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000155 Code = TYPE_CONSTANT_ARRAY;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000156}
157
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000158void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000159 VisitArrayType(T);
Sebastian Redl539c5062010-08-18 23:57:32 +0000160 Code = TYPE_INCOMPLETE_ARRAY;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000161}
162
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000163void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000164 VisitArrayType(T);
Douglas Gregor04318252009-07-06 15:59:29 +0000165 Writer.AddSourceLocation(T->getLBracketLoc(), Record);
166 Writer.AddSourceLocation(T->getRBracketLoc(), Record);
Douglas Gregor8f45df52009-04-16 22:23:12 +0000167 Writer.AddStmt(T->getSizeExpr());
Sebastian Redl539c5062010-08-18 23:57:32 +0000168 Code = TYPE_VARIABLE_ARRAY;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000169}
170
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000171void ASTTypeWriter::VisitVectorType(const VectorType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000172 Writer.AddTypeRef(T->getElementType(), Record);
173 Record.push_back(T->getNumElements());
Bob Wilsonaeb56442010-11-10 21:56:12 +0000174 Record.push_back(T->getVectorKind());
Sebastian Redl539c5062010-08-18 23:57:32 +0000175 Code = TYPE_VECTOR;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000176}
177
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000178void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000179 VisitVectorType(T);
Sebastian Redl539c5062010-08-18 23:57:32 +0000180 Code = TYPE_EXT_VECTOR;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000181}
182
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000183void ASTTypeWriter::VisitFunctionType(const FunctionType *T) {
Alp Toker314cc812014-01-25 16:55:45 +0000184 Writer.AddTypeRef(T->getReturnType(), Record);
Rafael Espindolac50c27c2010-03-30 20:24:48 +0000185 FunctionType::ExtInfo C = T->getExtInfo();
186 Record.push_back(C.getNoReturn());
Eli Friedmanc5b20b52011-04-09 08:18:08 +0000187 Record.push_back(C.getHasRegParm());
Rafael Espindola49b85ab2010-03-30 22:15:11 +0000188 Record.push_back(C.getRegParm());
Douglas Gregor8c940862010-01-18 17:14:39 +0000189 // FIXME: need to stabilize encoding of calling convention...
Rafael Espindolac50c27c2010-03-30 20:24:48 +0000190 Record.push_back(C.getCC());
John McCall31168b02011-06-15 23:02:42 +0000191 Record.push_back(C.getProducesResult());
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000192}
193
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000194void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000195 VisitFunctionType(T);
Sebastian Redl539c5062010-08-18 23:57:32 +0000196 Code = TYPE_FUNCTION_NO_PROTO;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000197}
198
Richard Smith564417a2014-03-20 21:47:22 +0000199static void addExceptionSpec(ASTWriter &Writer, const FunctionProtoType *T,
200 ASTWriter::RecordDataImpl &Record) {
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000201 Record.push_back(T->getExceptionSpecType());
202 if (T->getExceptionSpecType() == EST_Dynamic) {
203 Record.push_back(T->getNumExceptions());
204 for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
205 Writer.AddTypeRef(T->getExceptionType(I), Record);
206 } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
207 Writer.AddStmt(T->getNoexceptExpr());
Richard Smith8b987a92012-04-21 17:47:47 +0000208 } else if (T->getExceptionSpecType() == EST_Uninstantiated) {
209 Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
210 Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record);
Richard Smithd3b5c9082012-07-27 04:22:15 +0000211 } else if (T->getExceptionSpecType() == EST_Unevaluated) {
212 Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
Sebastian Redlfa453cf2011-03-12 11:50:43 +0000213 }
Richard Smith564417a2014-03-20 21:47:22 +0000214}
215
216void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) {
217 VisitFunctionType(T);
218 Record.push_back(T->getNumParams());
219 for (unsigned I = 0, N = T->getNumParams(); I != N; ++I)
220 Writer.AddTypeRef(T->getParamType(I), Record);
221 Record.push_back(T->isVariadic());
222 Record.push_back(T->hasTrailingReturn());
223 Record.push_back(T->getTypeQuals());
224 Record.push_back(static_cast<unsigned>(T->getRefQualifier()));
225 addExceptionSpec(Writer, T, Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000226 Code = TYPE_FUNCTION_PROTO;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000227}
228
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000229void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
John McCallb96ec562009-12-04 22:46:56 +0000230 Writer.AddDeclRef(T->getDecl(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000231 Code = TYPE_UNRESOLVED_USING;
John McCallb96ec562009-12-04 22:46:56 +0000232}
John McCallb96ec562009-12-04 22:46:56 +0000233
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000234void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000235 Writer.AddDeclRef(T->getDecl(), Record);
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +0000236 assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
237 Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000238 Code = TYPE_TYPEDEF;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000239}
240
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000241void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
Douglas Gregor8f45df52009-04-16 22:23:12 +0000242 Writer.AddStmt(T->getUnderlyingExpr());
Sebastian Redl539c5062010-08-18 23:57:32 +0000243 Code = TYPE_TYPEOF_EXPR;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000244}
245
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000246void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000247 Writer.AddTypeRef(T->getUnderlyingType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000248 Code = TYPE_TYPEOF;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000249}
250
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000251void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
Douglas Gregor81495f32012-02-12 18:42:33 +0000252 Writer.AddTypeRef(T->getUnderlyingType(), Record);
Anders Carlsson81df7b82009-06-24 19:06:50 +0000253 Writer.AddStmt(T->getUnderlyingExpr());
Sebastian Redl539c5062010-08-18 23:57:32 +0000254 Code = TYPE_DECLTYPE;
Anders Carlsson81df7b82009-06-24 19:06:50 +0000255}
256
Alexis Hunte852b102011-05-24 22:41:36 +0000257void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
258 Writer.AddTypeRef(T->getBaseType(), Record);
259 Writer.AddTypeRef(T->getUnderlyingType(), Record);
260 Record.push_back(T->getUTTKind());
261 Code = TYPE_UNARY_TRANSFORM;
262}
263
Richard Smith30482bc2011-02-20 03:19:35 +0000264void ASTTypeWriter::VisitAutoType(const AutoType *T) {
265 Writer.AddTypeRef(T->getDeducedType(), Record);
Richard Smith74aeef52013-04-26 16:15:35 +0000266 Record.push_back(T->isDecltypeAuto());
Richard Smith27d807c2013-04-30 13:56:41 +0000267 if (T->getDeducedType().isNull())
268 Record.push_back(T->isDependentType());
Richard Smith30482bc2011-02-20 03:19:35 +0000269 Code = TYPE_AUTO;
270}
271
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000272void ASTTypeWriter::VisitTagType(const TagType *T) {
Argyrios Kyrtzidisa4ed1812010-07-08 13:09:53 +0000273 Record.push_back(T->isDependentType());
Douglas Gregorf3bccd72012-01-17 19:21:53 +0000274 Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
Mike Stump11289f42009-09-09 15:08:12 +0000275 assert(!T->isBeingDefined() &&
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000276 "Cannot serialize in the middle of a type definition");
277}
278
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000279void ASTTypeWriter::VisitRecordType(const RecordType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000280 VisitTagType(T);
Sebastian Redl539c5062010-08-18 23:57:32 +0000281 Code = TYPE_RECORD;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000282}
283
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000284void ASTTypeWriter::VisitEnumType(const EnumType *T) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000285 VisitTagType(T);
Sebastian Redl539c5062010-08-18 23:57:32 +0000286 Code = TYPE_ENUM;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000287}
288
John McCall81904512011-01-06 01:58:22 +0000289void ASTTypeWriter::VisitAttributedType(const AttributedType *T) {
290 Writer.AddTypeRef(T->getModifiedType(), Record);
291 Writer.AddTypeRef(T->getEquivalentType(), Record);
292 Record.push_back(T->getAttrKind());
293 Code = TYPE_ATTRIBUTED;
294}
295
Mike Stump11289f42009-09-09 15:08:12 +0000296void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000297ASTTypeWriter::VisitSubstTemplateTypeParmType(
John McCallcebee162009-10-18 09:09:24 +0000298 const SubstTemplateTypeParmType *T) {
299 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
300 Writer.AddTypeRef(T->getReplacementType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000301 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM;
John McCallcebee162009-10-18 09:09:24 +0000302}
303
304void
Douglas Gregorada4b792011-01-14 02:55:32 +0000305ASTTypeWriter::VisitSubstTemplateTypeParmPackType(
306 const SubstTemplateTypeParmPackType *T) {
307 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
308 Writer.AddTemplateArgument(T->getArgumentPack(), Record);
309 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK;
310}
311
312void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000313ASTTypeWriter::VisitTemplateSpecializationType(
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000314 const TemplateSpecializationType *T) {
Argyrios Kyrtzidisa4ed1812010-07-08 13:09:53 +0000315 Record.push_back(T->isDependentType());
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000316 Writer.AddTemplateName(T->getTemplateName(), Record);
317 Record.push_back(T->getNumArgs());
318 for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end();
319 ArgI != ArgE; ++ArgI)
320 Writer.AddTemplateArgument(*ArgI, Record);
Richard Smith3f1b5d02011-05-05 21:57:07 +0000321 Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() :
322 T->isCanonicalUnqualified() ? QualType()
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +0000323 : T->getCanonicalTypeInternal(),
324 Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000325 Code = TYPE_TEMPLATE_SPECIALIZATION;
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000326}
327
328void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000329ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
Argyrios Kyrtzidis4a57bd02010-06-30 08:49:25 +0000330 VisitArrayType(T);
331 Writer.AddStmt(T->getSizeExpr());
332 Writer.AddSourceRange(T->getBracketsRange(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000333 Code = TYPE_DEPENDENT_SIZED_ARRAY;
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000334}
335
336void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000337ASTTypeWriter::VisitDependentSizedExtVectorType(
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000338 const DependentSizedExtVectorType *T) {
339 // FIXME: Serialize this type (C++ only)
David Blaikie83d382b2011-09-23 05:06:16 +0000340 llvm_unreachable("Cannot serialize dependent sized extended vector types");
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000341}
342
343void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000344ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000345 Record.push_back(T->getDepth());
346 Record.push_back(T->getIndex());
347 Record.push_back(T->isParameterPack());
Chandler Carruth08836322011-05-01 00:51:33 +0000348 Writer.AddDeclRef(T->getDecl(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000349 Code = TYPE_TEMPLATE_TYPE_PARM;
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000350}
351
352void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000353ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) {
Argyrios Kyrtzidisbfcacee2010-06-24 08:57:31 +0000354 Record.push_back(T->getKeyword());
355 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
356 Writer.AddIdentifierRef(T->getIdentifier(), Record);
Argyrios Kyrtzidise9290952010-07-02 11:55:24 +0000357 Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType()
358 : T->getCanonicalTypeInternal(),
359 Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000360 Code = TYPE_DEPENDENT_NAME;
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000361}
362
363void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000364ASTTypeWriter::VisitDependentTemplateSpecializationType(
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +0000365 const DependentTemplateSpecializationType *T) {
Argyrios Kyrtzidisf0f7a792010-06-25 16:24:58 +0000366 Record.push_back(T->getKeyword());
367 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
368 Writer.AddIdentifierRef(T->getIdentifier(), Record);
369 Record.push_back(T->getNumArgs());
370 for (DependentTemplateSpecializationType::iterator
371 I = T->begin(), E = T->end(); I != E; ++I)
372 Writer.AddTemplateArgument(*I, Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000373 Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000374}
375
Douglas Gregord2fa7662010-12-20 02:24:11 +0000376void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
377 Writer.AddTypeRef(T->getPattern(), Record);
David Blaikie05785d12013-02-20 22:23:23 +0000378 if (Optional<unsigned> NumExpansions = T->getNumExpansions())
Douglas Gregor0dca5fd2011-01-14 17:04:44 +0000379 Record.push_back(*NumExpansions + 1);
380 else
381 Record.push_back(0);
Douglas Gregord2fa7662010-12-20 02:24:11 +0000382 Code = TYPE_PACK_EXPANSION;
383}
384
Abramo Bagnara924a8f32010-12-10 16:29:40 +0000385void ASTTypeWriter::VisitParenType(const ParenType *T) {
386 Writer.AddTypeRef(T->getInnerType(), Record);
387 Code = TYPE_PAREN;
388}
389
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000390void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
Abramo Bagnara6150c882010-05-11 21:36:43 +0000391 Record.push_back(T->getKeyword());
Argyrios Kyrtzidisf0f7a792010-06-25 16:24:58 +0000392 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
393 Writer.AddTypeRef(T->getNamedType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000394 Code = TYPE_ELABORATED;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000395}
396
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000397void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
Douglas Gregor9f218892012-03-26 15:52:37 +0000398 Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
John McCall2408e322010-04-27 00:57:59 +0000399 Writer.AddTypeRef(T->getInjectedSpecializationType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000400 Code = TYPE_INJECTED_CLASS_NAME;
John McCalle78aac42010-03-10 03:28:59 +0000401}
402
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000403void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
Douglas Gregorf3bccd72012-01-17 19:21:53 +0000404 Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000405 Code = TYPE_OBJC_INTERFACE;
John McCall8b07ec22010-05-15 11:32:37 +0000406}
407
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000408void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
John McCall8b07ec22010-05-15 11:32:37 +0000409 Writer.AddTypeRef(T->getBaseType(), Record);
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000410 Record.push_back(T->getNumProtocols());
Aaron Ballman1683f7b2014-03-17 15:55:30 +0000411 for (const auto *I : T->quals())
412 Writer.AddDeclRef(I, Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000413 Code = TYPE_OBJC_OBJECT;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000414}
415
Steve Narofffb4330f2009-06-17 22:40:22 +0000416void
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000417ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
Mike Stump11289f42009-09-09 15:08:12 +0000418 Writer.AddTypeRef(T->getPointeeType(), Record);
Sebastian Redl539c5062010-08-18 23:57:32 +0000419 Code = TYPE_OBJC_OBJECT_POINTER;
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000420}
421
Eli Friedman0dfb8892011-10-06 23:00:33 +0000422void
423ASTTypeWriter::VisitAtomicType(const AtomicType *T) {
424 Writer.AddTypeRef(T->getValueType(), Record);
425 Code = TYPE_ATOMIC;
426}
427
John McCall8f115c62009-10-16 21:56:05 +0000428namespace {
429
430class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
Sebastian Redl55c0ad52010-08-18 23:56:21 +0000431 ASTWriter &Writer;
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000432 ASTWriter::RecordDataImpl &Record;
John McCall8f115c62009-10-16 21:56:05 +0000433
434public:
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000435 TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
John McCall8f115c62009-10-16 21:56:05 +0000436 : Writer(Writer), Record(Record) { }
437
John McCall17001972009-10-18 01:05:36 +0000438#define ABSTRACT_TYPELOC(CLASS, PARENT)
John McCall8f115c62009-10-16 21:56:05 +0000439#define TYPELOC(CLASS, PARENT) \
John McCall17001972009-10-18 01:05:36 +0000440 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
John McCall8f115c62009-10-16 21:56:05 +0000441#include "clang/AST/TypeLocNodes.def"
442
John McCall17001972009-10-18 01:05:36 +0000443 void VisitArrayTypeLoc(ArrayTypeLoc TyLoc);
444 void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc);
John McCall8f115c62009-10-16 21:56:05 +0000445};
446
447}
448
John McCall17001972009-10-18 01:05:36 +0000449void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
450 // nothing to do
John McCall8f115c62009-10-16 21:56:05 +0000451}
John McCall17001972009-10-18 01:05:36 +0000452void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
Douglas Gregorc9b7a592010-01-18 18:04:31 +0000453 Writer.AddSourceLocation(TL.getBuiltinLoc(), Record);
454 if (TL.needsExtraLocalData()) {
455 Record.push_back(TL.getWrittenTypeSpec());
456 Record.push_back(TL.getWrittenSignSpec());
457 Record.push_back(TL.getWrittenWidthSpec());
458 Record.push_back(TL.hasModeAttr());
459 }
John McCall8f115c62009-10-16 21:56:05 +0000460}
John McCall17001972009-10-18 01:05:36 +0000461void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
462 Writer.AddSourceLocation(TL.getNameLoc(), Record);
John McCall8f115c62009-10-16 21:56:05 +0000463}
John McCall17001972009-10-18 01:05:36 +0000464void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
465 Writer.AddSourceLocation(TL.getStarLoc(), Record);
John McCall8f115c62009-10-16 21:56:05 +0000466}
Reid Kleckner8a365022013-06-24 17:51:48 +0000467void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
468 // nothing to do
469}
Reid Kleckner0503a872013-12-05 01:23:43 +0000470void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
471 // nothing to do
472}
John McCall17001972009-10-18 01:05:36 +0000473void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
474 Writer.AddSourceLocation(TL.getCaretLoc(), Record);
John McCall8f115c62009-10-16 21:56:05 +0000475}
John McCall17001972009-10-18 01:05:36 +0000476void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
477 Writer.AddSourceLocation(TL.getAmpLoc(), Record);
John McCall8f115c62009-10-16 21:56:05 +0000478}
John McCall17001972009-10-18 01:05:36 +0000479void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
480 Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record);
John McCall8f115c62009-10-16 21:56:05 +0000481}
John McCall17001972009-10-18 01:05:36 +0000482void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
483 Writer.AddSourceLocation(TL.getStarLoc(), Record);
Abramo Bagnara509357842011-03-05 14:42:21 +0000484 Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record);
John McCall8f115c62009-10-16 21:56:05 +0000485}
John McCall17001972009-10-18 01:05:36 +0000486void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
487 Writer.AddSourceLocation(TL.getLBracketLoc(), Record);
488 Writer.AddSourceLocation(TL.getRBracketLoc(), Record);
489 Record.push_back(TL.getSizeExpr() ? 1 : 0);
490 if (TL.getSizeExpr())
491 Writer.AddStmt(TL.getSizeExpr());
John McCall8f115c62009-10-16 21:56:05 +0000492}
John McCall17001972009-10-18 01:05:36 +0000493void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
494 VisitArrayTypeLoc(TL);
495}
496void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
497 VisitArrayTypeLoc(TL);
498}
499void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
500 VisitArrayTypeLoc(TL);
501}
502void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
503 DependentSizedArrayTypeLoc TL) {
504 VisitArrayTypeLoc(TL);
505}
506void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
507 DependentSizedExtVectorTypeLoc TL) {
508 Writer.AddSourceLocation(TL.getNameLoc(), Record);
509}
510void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
511 Writer.AddSourceLocation(TL.getNameLoc(), Record);
512}
513void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
514 Writer.AddSourceLocation(TL.getNameLoc(), Record);
515}
516void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
Abramo Bagnaraf2a79d92011-03-12 11:17:06 +0000517 Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record);
Abramo Bagnaraaeeb9892012-10-04 21:42:10 +0000518 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
519 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Abramo Bagnaraf2a79d92011-03-12 11:17:06 +0000520 Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record);
Alp Tokerb3fd5cf2014-01-21 00:32:38 +0000521 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
522 Writer.AddDeclRef(TL.getParam(i), Record);
John McCall17001972009-10-18 01:05:36 +0000523}
524void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
525 VisitFunctionTypeLoc(TL);
526}
527void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
528 VisitFunctionTypeLoc(TL);
529}
John McCallb96ec562009-12-04 22:46:56 +0000530void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
531 Writer.AddSourceLocation(TL.getNameLoc(), Record);
532}
John McCall17001972009-10-18 01:05:36 +0000533void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
534 Writer.AddSourceLocation(TL.getNameLoc(), Record);
535}
536void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
John McCalle8595032010-01-13 20:03:27 +0000537 Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
538 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
539 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
John McCall17001972009-10-18 01:05:36 +0000540}
541void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
John McCalle8595032010-01-13 20:03:27 +0000542 Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
543 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
544 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
545 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
John McCall17001972009-10-18 01:05:36 +0000546}
547void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
548 Writer.AddSourceLocation(TL.getNameLoc(), Record);
549}
Alexis Hunte852b102011-05-24 22:41:36 +0000550void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
551 Writer.AddSourceLocation(TL.getKWLoc(), Record);
552 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
553 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
554 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
555}
Richard Smith30482bc2011-02-20 03:19:35 +0000556void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
557 Writer.AddSourceLocation(TL.getNameLoc(), Record);
558}
John McCall17001972009-10-18 01:05:36 +0000559void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
560 Writer.AddSourceLocation(TL.getNameLoc(), Record);
561}
562void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
563 Writer.AddSourceLocation(TL.getNameLoc(), Record);
564}
John McCall81904512011-01-06 01:58:22 +0000565void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
566 Writer.AddSourceLocation(TL.getAttrNameLoc(), Record);
567 if (TL.hasAttrOperand()) {
568 SourceRange range = TL.getAttrOperandParensRange();
569 Writer.AddSourceLocation(range.getBegin(), Record);
570 Writer.AddSourceLocation(range.getEnd(), Record);
571 }
572 if (TL.hasAttrExprOperand()) {
573 Expr *operand = TL.getAttrExprOperand();
574 Record.push_back(operand ? 1 : 0);
575 if (operand) Writer.AddStmt(operand);
576 } else if (TL.hasAttrEnumOperand()) {
577 Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record);
578 }
579}
John McCall17001972009-10-18 01:05:36 +0000580void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
581 Writer.AddSourceLocation(TL.getNameLoc(), Record);
582}
John McCallcebee162009-10-18 09:09:24 +0000583void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
584 SubstTemplateTypeParmTypeLoc TL) {
585 Writer.AddSourceLocation(TL.getNameLoc(), Record);
586}
Douglas Gregorada4b792011-01-14 02:55:32 +0000587void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
588 SubstTemplateTypeParmPackTypeLoc TL) {
589 Writer.AddSourceLocation(TL.getNameLoc(), Record);
590}
John McCall17001972009-10-18 01:05:36 +0000591void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
592 TemplateSpecializationTypeLoc TL) {
Abramo Bagnara48c05be2012-02-06 14:41:24 +0000593 Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
John McCall0ad16662009-10-29 08:12:44 +0000594 Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
595 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
596 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
597 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +0000598 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
599 TL.getArgLoc(i).getLocInfo(), Record);
John McCall17001972009-10-18 01:05:36 +0000600}
Abramo Bagnara924a8f32010-12-10 16:29:40 +0000601void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
602 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
603 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
604}
Abramo Bagnara6150c882010-05-11 21:36:43 +0000605void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Abramo Bagnara9033e2b2012-02-06 19:09:27 +0000606 Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
Douglas Gregor844cb502011-03-01 18:12:44 +0000607 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
John McCall17001972009-10-18 01:05:36 +0000608}
John McCalle78aac42010-03-10 03:28:59 +0000609void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
610 Writer.AddSourceLocation(TL.getNameLoc(), Record);
611}
Douglas Gregorc1d2d8a2010-03-31 17:34:00 +0000612void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
Abramo Bagnara9033e2b2012-02-06 19:09:27 +0000613 Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
Douglas Gregor3d0da5f2011-03-01 01:34:45 +0000614 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
John McCall17001972009-10-18 01:05:36 +0000615 Writer.AddSourceLocation(TL.getNameLoc(), Record);
616}
John McCallc392f372010-06-11 00:33:02 +0000617void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
618 DependentTemplateSpecializationTypeLoc TL) {
Abramo Bagnara48c05be2012-02-06 14:41:24 +0000619 Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
Douglas Gregora7a795b2011-03-01 20:11:18 +0000620 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
Abramo Bagnarae0a70b22012-02-06 22:45:07 +0000621 Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
Abramo Bagnara48c05be2012-02-06 14:41:24 +0000622 Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
John McCallc392f372010-06-11 00:33:02 +0000623 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
624 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
625 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +0000626 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
627 TL.getArgLoc(I).getLocInfo(), Record);
John McCallc392f372010-06-11 00:33:02 +0000628}
Douglas Gregord2fa7662010-12-20 02:24:11 +0000629void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
630 Writer.AddSourceLocation(TL.getEllipsisLoc(), Record);
631}
John McCall17001972009-10-18 01:05:36 +0000632void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
633 Writer.AddSourceLocation(TL.getNameLoc(), Record);
John McCall8b07ec22010-05-15 11:32:37 +0000634}
635void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
636 Record.push_back(TL.hasBaseTypeAsWritten());
John McCall17001972009-10-18 01:05:36 +0000637 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
638 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
639 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
640 Writer.AddSourceLocation(TL.getProtocolLoc(i), Record);
John McCall8f115c62009-10-16 21:56:05 +0000641}
John McCallfc93cf92009-10-22 22:37:11 +0000642void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
643 Writer.AddSourceLocation(TL.getStarLoc(), Record);
John McCallfc93cf92009-10-22 22:37:11 +0000644}
Eli Friedman0dfb8892011-10-06 23:00:33 +0000645void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
646 Writer.AddSourceLocation(TL.getKWLoc(), Record);
647 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
648 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
649}
John McCall8f115c62009-10-16 21:56:05 +0000650
Chris Lattner19cea4e2009-04-22 05:57:30 +0000651//===----------------------------------------------------------------------===//
Sebastian Redl55c0ad52010-08-18 23:56:21 +0000652// ASTWriter Implementation
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000653//===----------------------------------------------------------------------===//
654
Chris Lattner28fa4e62009-04-26 22:26:21 +0000655static void EmitBlockID(unsigned ID, const char *Name,
656 llvm::BitstreamWriter &Stream,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000657 ASTWriter::RecordDataImpl &Record) {
Chris Lattner28fa4e62009-04-26 22:26:21 +0000658 Record.clear();
659 Record.push_back(ID);
660 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
661
662 // Emit the block name if present.
663 if (Name == 0 || Name[0] == 0) return;
664 Record.clear();
665 while (*Name)
666 Record.push_back(*Name++);
667 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
668}
669
670static void EmitRecordID(unsigned ID, const char *Name,
671 llvm::BitstreamWriter &Stream,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000672 ASTWriter::RecordDataImpl &Record) {
Chris Lattner28fa4e62009-04-26 22:26:21 +0000673 Record.clear();
674 Record.push_back(ID);
675 while (*Name)
676 Record.push_back(*Name++);
677 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000678}
679
680static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000681 ASTWriter::RecordDataImpl &Record) {
Sebastian Redl539c5062010-08-18 23:57:32 +0000682#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
Chris Lattnerccac3a62009-04-27 00:49:53 +0000683 RECORD(STMT_STOP);
684 RECORD(STMT_NULL_PTR);
685 RECORD(STMT_NULL);
686 RECORD(STMT_COMPOUND);
687 RECORD(STMT_CASE);
688 RECORD(STMT_DEFAULT);
689 RECORD(STMT_LABEL);
Richard Smithc202b282012-04-14 00:33:13 +0000690 RECORD(STMT_ATTRIBUTED);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000691 RECORD(STMT_IF);
692 RECORD(STMT_SWITCH);
693 RECORD(STMT_WHILE);
694 RECORD(STMT_DO);
695 RECORD(STMT_FOR);
696 RECORD(STMT_GOTO);
697 RECORD(STMT_INDIRECT_GOTO);
698 RECORD(STMT_CONTINUE);
699 RECORD(STMT_BREAK);
700 RECORD(STMT_RETURN);
701 RECORD(STMT_DECL);
Chad Rosierde70e0e2012-08-25 00:11:56 +0000702 RECORD(STMT_GCCASM);
Chad Rosiere30d4992012-08-24 23:51:02 +0000703 RECORD(STMT_MSASM);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000704 RECORD(EXPR_PREDEFINED);
705 RECORD(EXPR_DECL_REF);
706 RECORD(EXPR_INTEGER_LITERAL);
707 RECORD(EXPR_FLOATING_LITERAL);
708 RECORD(EXPR_IMAGINARY_LITERAL);
709 RECORD(EXPR_STRING_LITERAL);
710 RECORD(EXPR_CHARACTER_LITERAL);
711 RECORD(EXPR_PAREN);
712 RECORD(EXPR_UNARY_OPERATOR);
713 RECORD(EXPR_SIZEOF_ALIGN_OF);
714 RECORD(EXPR_ARRAY_SUBSCRIPT);
715 RECORD(EXPR_CALL);
716 RECORD(EXPR_MEMBER);
717 RECORD(EXPR_BINARY_OPERATOR);
718 RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR);
719 RECORD(EXPR_CONDITIONAL_OPERATOR);
720 RECORD(EXPR_IMPLICIT_CAST);
721 RECORD(EXPR_CSTYLE_CAST);
722 RECORD(EXPR_COMPOUND_LITERAL);
723 RECORD(EXPR_EXT_VECTOR_ELEMENT);
724 RECORD(EXPR_INIT_LIST);
725 RECORD(EXPR_DESIGNATED_INIT);
726 RECORD(EXPR_IMPLICIT_VALUE_INIT);
727 RECORD(EXPR_VA_ARG);
728 RECORD(EXPR_ADDR_LABEL);
729 RECORD(EXPR_STMT);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000730 RECORD(EXPR_CHOOSE);
731 RECORD(EXPR_GNU_NULL);
732 RECORD(EXPR_SHUFFLE_VECTOR);
733 RECORD(EXPR_BLOCK);
Peter Collingbourne91147592011-04-15 00:35:48 +0000734 RECORD(EXPR_GENERIC_SELECTION);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000735 RECORD(EXPR_OBJC_STRING_LITERAL);
Patrick Beard0caa3942012-04-19 00:25:12 +0000736 RECORD(EXPR_OBJC_BOXED_EXPRESSION);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000737 RECORD(EXPR_OBJC_ARRAY_LITERAL);
738 RECORD(EXPR_OBJC_DICTIONARY_LITERAL);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000739 RECORD(EXPR_OBJC_ENCODE);
740 RECORD(EXPR_OBJC_SELECTOR_EXPR);
741 RECORD(EXPR_OBJC_PROTOCOL_EXPR);
742 RECORD(EXPR_OBJC_IVAR_REF_EXPR);
743 RECORD(EXPR_OBJC_PROPERTY_REF_EXPR);
744 RECORD(EXPR_OBJC_KVC_REF_EXPR);
745 RECORD(EXPR_OBJC_MESSAGE_EXPR);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000746 RECORD(STMT_OBJC_FOR_COLLECTION);
747 RECORD(STMT_OBJC_CATCH);
748 RECORD(STMT_OBJC_FINALLY);
749 RECORD(STMT_OBJC_AT_TRY);
750 RECORD(STMT_OBJC_AT_SYNCHRONIZED);
751 RECORD(STMT_OBJC_AT_THROW);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000752 RECORD(EXPR_OBJC_BOOL_LITERAL);
Sam Weinige83b3ac2010-02-07 06:32:43 +0000753 RECORD(EXPR_CXX_OPERATOR_CALL);
754 RECORD(EXPR_CXX_CONSTRUCT);
755 RECORD(EXPR_CXX_STATIC_CAST);
756 RECORD(EXPR_CXX_DYNAMIC_CAST);
757 RECORD(EXPR_CXX_REINTERPRET_CAST);
758 RECORD(EXPR_CXX_CONST_CAST);
759 RECORD(EXPR_CXX_FUNCTIONAL_CAST);
Richard Smithc67fdd42012-03-07 08:35:16 +0000760 RECORD(EXPR_USER_DEFINED_LITERAL);
Richard Smithcc1b96d2013-06-12 22:31:48 +0000761 RECORD(EXPR_CXX_STD_INITIALIZER_LIST);
Sam Weinige83b3ac2010-02-07 06:32:43 +0000762 RECORD(EXPR_CXX_BOOL_LITERAL);
763 RECORD(EXPR_CXX_NULL_PTR_LITERAL);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000764 RECORD(EXPR_CXX_TYPEID_EXPR);
765 RECORD(EXPR_CXX_TYPEID_TYPE);
766 RECORD(EXPR_CXX_UUIDOF_EXPR);
767 RECORD(EXPR_CXX_UUIDOF_TYPE);
768 RECORD(EXPR_CXX_THIS);
769 RECORD(EXPR_CXX_THROW);
770 RECORD(EXPR_CXX_DEFAULT_ARG);
771 RECORD(EXPR_CXX_BIND_TEMPORARY);
772 RECORD(EXPR_CXX_SCALAR_VALUE_INIT);
773 RECORD(EXPR_CXX_NEW);
774 RECORD(EXPR_CXX_DELETE);
775 RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR);
776 RECORD(EXPR_EXPR_WITH_CLEANUPS);
777 RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER);
778 RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF);
779 RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT);
780 RECORD(EXPR_CXX_UNRESOLVED_MEMBER);
781 RECORD(EXPR_CXX_UNRESOLVED_LOOKUP);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000782 RECORD(EXPR_CXX_NOEXCEPT);
783 RECORD(EXPR_OPAQUE_VALUE);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000784 RECORD(EXPR_PACK_EXPANSION);
785 RECORD(EXPR_SIZEOF_PACK);
786 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK);
Peter Collingbourne41f85462011-02-09 21:07:24 +0000787 RECORD(EXPR_CUDA_KERNEL_CALL);
Chris Lattnerccac3a62009-04-27 00:49:53 +0000788#undef RECORD
Chris Lattner28fa4e62009-04-26 22:26:21 +0000789}
Mike Stump11289f42009-09-09 15:08:12 +0000790
Sebastian Redl55c0ad52010-08-18 23:56:21 +0000791void ASTWriter::WriteBlockInfoBlock() {
Chris Lattner28fa4e62009-04-26 22:26:21 +0000792 RecordData Record;
793 Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3);
Mike Stump11289f42009-09-09 15:08:12 +0000794
Sebastian Redl539c5062010-08-18 23:57:32 +0000795#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
796#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
Mike Stump11289f42009-09-09 15:08:12 +0000797
Douglas Gregor0aa21c92012-10-18 18:27:37 +0000798 // Control Block.
799 BLOCK(CONTROL_BLOCK);
800 RECORD(METADATA);
Ben Langmuirbeee15e2014-04-14 18:00:01 +0000801 RECORD(MODULE_NAME);
802 RECORD(MODULE_MAP_FILE);
Douglas Gregor0aa21c92012-10-18 18:27:37 +0000803 RECORD(IMPORTS);
804 RECORD(LANGUAGE_OPTIONS);
805 RECORD(TARGET_OPTIONS);
Douglas Gregorfad10d82012-10-18 18:36:53 +0000806 RECORD(ORIGINAL_FILE);
Douglas Gregor0aa21c92012-10-18 18:27:37 +0000807 RECORD(ORIGINAL_PCH_DIR);
Argyrios Kyrtzidis52595242012-11-15 18:57:27 +0000808 RECORD(ORIGINAL_FILE_ID);
Douglas Gregor3120d2c2012-10-22 18:42:04 +0000809 RECORD(INPUT_FILE_OFFSETS);
Douglas Gregor8263ffb2012-10-24 15:17:15 +0000810 RECORD(DIAGNOSTIC_OPTIONS);
Douglas Gregorc6317db2012-10-24 15:49:58 +0000811 RECORD(FILE_SYSTEM_OPTIONS);
Douglas Gregor2d302362012-10-24 16:50:34 +0000812 RECORD(HEADER_SEARCH_OPTIONS);
Douglas Gregorb6af6c22012-10-24 20:05:57 +0000813 RECORD(PREPROCESSOR_OPTIONS);
814
Douglas Gregor108cb222012-10-19 00:45:00 +0000815 BLOCK(INPUT_FILES_BLOCK);
816 RECORD(INPUT_FILE);
817
Douglas Gregor0aa21c92012-10-18 18:27:37 +0000818 // AST Top-Level Block.
819 BLOCK(AST_BLOCK);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000820 RECORD(TYPE_OFFSET);
821 RECORD(DECL_OFFSET);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000822 RECORD(IDENTIFIER_OFFSET);
823 RECORD(IDENTIFIER_TABLE);
Ben Langmuir332aafe2014-01-31 01:06:56 +0000824 RECORD(EAGERLY_DESERIALIZED_DECLS);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000825 RECORD(SPECIAL_TYPES);
826 RECORD(STATISTICS);
827 RECORD(TENTATIVE_DEFINITIONS);
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +0000828 RECORD(UNUSED_FILESCOPED_DECLS);
Richard Smith78165b52013-01-10 23:43:47 +0000829 RECORD(LOCALLY_SCOPED_EXTERN_C_DECLS);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000830 RECORD(SELECTOR_OFFSETS);
831 RECORD(METHOD_POOL);
832 RECORD(PP_COUNTER_VALUE);
Douglas Gregor258ae542009-04-27 06:38:32 +0000833 RECORD(SOURCE_LOCATION_OFFSETS);
834 RECORD(SOURCE_LOCATION_PRELOADS);
Douglas Gregor61cac2b2009-04-27 20:06:05 +0000835 RECORD(EXT_VECTOR_DECLS);
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +0000836 RECORD(PPD_ENTITIES_OFFSETS);
Fariborz Jahanianc51609a2010-07-23 19:11:11 +0000837 RECORD(REFERENCED_SELECTOR_POOL);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000838 RECORD(TU_UPDATE_LEXICAL);
Douglas Gregor358cd442012-01-15 16:58:34 +0000839 RECORD(LOCAL_REDECLARATIONS_MAP);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000840 RECORD(SEMA_DECL_REFS);
841 RECORD(WEAK_UNDECLARED_IDENTIFIERS);
842 RECORD(PENDING_IMPLICIT_INSTANTIATIONS);
843 RECORD(DECL_REPLACEMENTS);
844 RECORD(UPDATE_VISIBLE);
845 RECORD(DECL_UPDATE_OFFSETS);
846 RECORD(DECL_UPDATES);
847 RECORD(CXX_BASE_SPECIFIER_OFFSETS);
848 RECORD(DIAG_PRAGMA_MAPPINGS);
Peter Collingbourne5df20e02011-02-15 19:46:30 +0000849 RECORD(CUDA_SPECIAL_DECL_REFS);
Douglas Gregor09b69892011-02-10 17:09:37 +0000850 RECORD(HEADER_SEARCH_TABLE);
Peter Collingbourne5df20e02011-02-15 19:46:30 +0000851 RECORD(FP_PRAGMA_OPTIONS);
852 RECORD(OPENCL_EXTENSIONS);
Alexis Hunt27a761d2011-05-04 23:29:54 +0000853 RECORD(DELEGATING_CTORS);
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000854 RECORD(KNOWN_NAMESPACES);
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000855 RECORD(UNDEFINED_BUT_USED);
Douglas Gregor78d0b572011-08-04 16:39:39 +0000856 RECORD(MODULE_OFFSET_MAP);
857 RECORD(SOURCE_MANAGER_LINE_TABLE);
Douglas Gregor404cdde2012-01-27 01:47:08 +0000858 RECORD(OBJC_CATEGORIES_MAP);
Douglas Gregor66e4add2011-12-19 21:09:25 +0000859 RECORD(FILE_SORTED_DECLS);
860 RECORD(IMPORTED_MODULES);
Douglas Gregor358cd442012-01-15 16:58:34 +0000861 RECORD(MERGED_DECLARATIONS);
862 RECORD(LOCAL_REDECLARATIONS);
Douglas Gregor404cdde2012-01-27 01:47:08 +0000863 RECORD(OBJC_CATEGORIES);
Douglas Gregorcb28f9d2012-10-09 23:05:51 +0000864 RECORD(MACRO_OFFSET);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +0000865 RECORD(MACRO_TABLE);
Richard Smithe40f2ba2013-08-07 21:41:30 +0000866 RECORD(LATE_PARSED_TEMPLATE);
Douglas Gregor358cd442012-01-15 16:58:34 +0000867
Chris Lattner28fa4e62009-04-26 22:26:21 +0000868 // SourceManager Block.
Chris Lattner64031982009-04-27 00:40:25 +0000869 BLOCK(SOURCE_MANAGER_BLOCK);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000870 RECORD(SM_SLOC_FILE_ENTRY);
871 RECORD(SM_SLOC_BUFFER_ENTRY);
872 RECORD(SM_SLOC_BUFFER_BLOB);
Chandler Carruthf92ac9e2011-07-15 07:25:21 +0000873 RECORD(SM_SLOC_EXPANSION_ENTRY);
Mike Stump11289f42009-09-09 15:08:12 +0000874
Chris Lattner28fa4e62009-04-26 22:26:21 +0000875 // Preprocessor Block.
Chris Lattner64031982009-04-27 00:40:25 +0000876 BLOCK(PREPROCESSOR_BLOCK);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000877 RECORD(PP_MACRO_OBJECT_LIKE);
878 RECORD(PP_MACRO_FUNCTION_LIKE);
879 RECORD(PP_TOKEN);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000880
Douglas Gregor12bfa382009-10-17 00:13:19 +0000881 // Decls and Types block.
882 BLOCK(DECLTYPES_BLOCK);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000883 RECORD(TYPE_EXT_QUAL);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000884 RECORD(TYPE_COMPLEX);
885 RECORD(TYPE_POINTER);
886 RECORD(TYPE_BLOCK_POINTER);
887 RECORD(TYPE_LVALUE_REFERENCE);
888 RECORD(TYPE_RVALUE_REFERENCE);
889 RECORD(TYPE_MEMBER_POINTER);
890 RECORD(TYPE_CONSTANT_ARRAY);
891 RECORD(TYPE_INCOMPLETE_ARRAY);
892 RECORD(TYPE_VARIABLE_ARRAY);
893 RECORD(TYPE_VECTOR);
894 RECORD(TYPE_EXT_VECTOR);
895 RECORD(TYPE_FUNCTION_PROTO);
896 RECORD(TYPE_FUNCTION_NO_PROTO);
897 RECORD(TYPE_TYPEDEF);
898 RECORD(TYPE_TYPEOF_EXPR);
899 RECORD(TYPE_TYPEOF);
900 RECORD(TYPE_RECORD);
901 RECORD(TYPE_ENUM);
902 RECORD(TYPE_OBJC_INTERFACE);
John McCall94f619a2010-05-16 02:12:35 +0000903 RECORD(TYPE_OBJC_OBJECT);
Steve Narofffb4330f2009-06-17 22:40:22 +0000904 RECORD(TYPE_OBJC_OBJECT_POINTER);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000905 RECORD(TYPE_DECLTYPE);
906 RECORD(TYPE_ELABORATED);
907 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
908 RECORD(TYPE_UNRESOLVED_USING);
909 RECORD(TYPE_INJECTED_CLASS_NAME);
910 RECORD(TYPE_OBJC_OBJECT);
911 RECORD(TYPE_TEMPLATE_TYPE_PARM);
912 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
913 RECORD(TYPE_DEPENDENT_NAME);
914 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
915 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
916 RECORD(TYPE_PAREN);
917 RECORD(TYPE_PACK_EXPANSION);
918 RECORD(TYPE_ATTRIBUTED);
919 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
Eli Friedman0dfb8892011-10-06 23:00:33 +0000920 RECORD(TYPE_ATOMIC);
Chris Lattnerdb397b62009-04-26 22:32:16 +0000921 RECORD(DECL_TYPEDEF);
922 RECORD(DECL_ENUM);
923 RECORD(DECL_RECORD);
924 RECORD(DECL_ENUM_CONSTANT);
925 RECORD(DECL_FUNCTION);
926 RECORD(DECL_OBJC_METHOD);
927 RECORD(DECL_OBJC_INTERFACE);
928 RECORD(DECL_OBJC_PROTOCOL);
929 RECORD(DECL_OBJC_IVAR);
930 RECORD(DECL_OBJC_AT_DEFS_FIELD);
Chris Lattnerdb397b62009-04-26 22:32:16 +0000931 RECORD(DECL_OBJC_CATEGORY);
932 RECORD(DECL_OBJC_CATEGORY_IMPL);
933 RECORD(DECL_OBJC_IMPLEMENTATION);
934 RECORD(DECL_OBJC_COMPATIBLE_ALIAS);
935 RECORD(DECL_OBJC_PROPERTY);
936 RECORD(DECL_OBJC_PROPERTY_IMPL);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000937 RECORD(DECL_FIELD);
John McCall5e77d762013-04-16 07:28:30 +0000938 RECORD(DECL_MS_PROPERTY);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000939 RECORD(DECL_VAR);
Chris Lattnerdb397b62009-04-26 22:32:16 +0000940 RECORD(DECL_IMPLICIT_PARAM);
Chris Lattner28fa4e62009-04-26 22:26:21 +0000941 RECORD(DECL_PARM_VAR);
Chris Lattnerdb397b62009-04-26 22:32:16 +0000942 RECORD(DECL_FILE_SCOPE_ASM);
943 RECORD(DECL_BLOCK);
944 RECORD(DECL_CONTEXT_LEXICAL);
945 RECORD(DECL_CONTEXT_VISIBLE);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000946 RECORD(DECL_NAMESPACE);
947 RECORD(DECL_NAMESPACE_ALIAS);
948 RECORD(DECL_USING);
949 RECORD(DECL_USING_SHADOW);
950 RECORD(DECL_USING_DIRECTIVE);
951 RECORD(DECL_UNRESOLVED_USING_VALUE);
952 RECORD(DECL_UNRESOLVED_USING_TYPENAME);
953 RECORD(DECL_LINKAGE_SPEC);
954 RECORD(DECL_CXX_RECORD);
955 RECORD(DECL_CXX_METHOD);
956 RECORD(DECL_CXX_CONSTRUCTOR);
957 RECORD(DECL_CXX_DESTRUCTOR);
958 RECORD(DECL_CXX_CONVERSION);
959 RECORD(DECL_ACCESS_SPEC);
960 RECORD(DECL_FRIEND);
961 RECORD(DECL_FRIEND_TEMPLATE);
962 RECORD(DECL_CLASS_TEMPLATE);
963 RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION);
964 RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000965 RECORD(DECL_VAR_TEMPLATE);
966 RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION);
967 RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION);
Douglas Gregor0beaec02011-02-08 16:34:17 +0000968 RECORD(DECL_FUNCTION_TEMPLATE);
969 RECORD(DECL_TEMPLATE_TYPE_PARM);
970 RECORD(DECL_NON_TYPE_TEMPLATE_PARM);
971 RECORD(DECL_TEMPLATE_TEMPLATE_PARM);
972 RECORD(DECL_STATIC_ASSERT);
973 RECORD(DECL_CXX_BASE_SPECIFIERS);
974 RECORD(DECL_INDIRECTFIELD);
975 RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK);
976
Douglas Gregor03412ba2011-06-03 02:27:19 +0000977 // Statements and Exprs can occur in the Decls and Types block.
978 AddStmtsExprs(Stream, Record);
979
Douglas Gregor92a96f52011-02-08 21:58:10 +0000980 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
Chandler Carruthf92ac9e2011-07-15 07:25:21 +0000981 RECORD(PPD_MACRO_EXPANSION);
Douglas Gregor92a96f52011-02-08 21:58:10 +0000982 RECORD(PPD_MACRO_DEFINITION);
983 RECORD(PPD_INCLUSION_DIRECTIVE);
984
Chris Lattner28fa4e62009-04-26 22:26:21 +0000985#undef RECORD
986#undef BLOCK
987 Stream.ExitBlock();
988}
989
Douglas Gregor0086a5a2009-07-07 00:12:59 +0000990/// \brief Adjusts the given filename to only write out the portion of the
991/// filename that is not part of the system root directory.
Mike Stump11289f42009-09-09 15:08:12 +0000992///
Douglas Gregor0086a5a2009-07-07 00:12:59 +0000993/// \param Filename the file name to adjust.
994///
995/// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and
996/// the returned filename will be adjusted by this system root.
997///
998/// \returns either the original filename (if it needs no adjustment) or the
999/// adjusted filename (which points into the @p Filename parameter).
Mike Stump11289f42009-09-09 15:08:12 +00001000static const char *
Douglas Gregorc567ba22011-07-22 16:35:34 +00001001adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) {
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001002 assert(Filename && "No file name to adjust?");
Mike Stump11289f42009-09-09 15:08:12 +00001003
Douglas Gregorc567ba22011-07-22 16:35:34 +00001004 if (isysroot.empty())
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001005 return Filename;
Mike Stump11289f42009-09-09 15:08:12 +00001006
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001007 // Verify that the filename and the system root have the same prefix.
1008 unsigned Pos = 0;
Douglas Gregorc567ba22011-07-22 16:35:34 +00001009 for (; Filename[Pos] && Pos < isysroot.size(); ++Pos)
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001010 if (Filename[Pos] != isysroot[Pos])
1011 return Filename; // Prefixes don't match.
Mike Stump11289f42009-09-09 15:08:12 +00001012
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001013 // We hit the end of the filename before we hit the end of the system root.
1014 if (!Filename[Pos])
1015 return Filename;
Mike Stump11289f42009-09-09 15:08:12 +00001016
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001017 // If the file name has a '/' at the current position, skip over the '/'.
1018 // We distinguish sysroot-based includes from absolute includes by the
1019 // absence of '/' at the beginning of sysroot-based includes.
1020 if (Filename[Pos] == '/')
1021 ++Pos;
Mike Stump11289f42009-09-09 15:08:12 +00001022
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001023 return Filename + Pos;
1024}
Chris Lattner28fa4e62009-04-26 22:26:21 +00001025
Douglas Gregor112b9072012-10-18 05:31:06 +00001026/// \brief Write the control block.
Douglas Gregor2d302362012-10-24 16:50:34 +00001027void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context,
1028 StringRef isysroot,
Douglas Gregor112b9072012-10-18 05:31:06 +00001029 const std::string &OutputFile) {
Douglas Gregorbfbde532009-04-10 21:16:55 +00001030 using namespace llvm;
Douglas Gregor0aa21c92012-10-18 18:27:37 +00001031 Stream.EnterSubblock(CONTROL_BLOCK_ID, 5);
1032 RecordData Record;
Douglas Gregor112b9072012-10-18 05:31:06 +00001033
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001034 // Metadata
Douglas Gregor0aa21c92012-10-18 18:27:37 +00001035 BitCodeAbbrev *MetadataAbbrev = new BitCodeAbbrev();
1036 MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA));
1037 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major
1038 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor
1039 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj.
1040 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min.
1041 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
1042 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors
1043 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
1044 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev);
1045 Record.push_back(METADATA);
Sebastian Redl539c5062010-08-18 23:57:32 +00001046 Record.push_back(VERSION_MAJOR);
1047 Record.push_back(VERSION_MINOR);
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001048 Record.push_back(CLANG_VERSION_MAJOR);
1049 Record.push_back(CLANG_VERSION_MINOR);
Douglas Gregorc567ba22011-07-22 16:35:34 +00001050 Record.push_back(!isysroot.empty());
Argyrios Kyrtzidis4a280ff2012-03-07 01:51:17 +00001051 Record.push_back(ASTHasCompilerErrors);
Douglas Gregor0aa21c92012-10-18 18:27:37 +00001052 Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record,
1053 getClangFullRepositoryVersion());
Douglas Gregor29cc6422011-08-17 21:07:30 +00001054
Ben Langmuirbeee15e2014-04-14 18:00:01 +00001055 // Module name
1056 if (WritingModule) {
1057 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1058 Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME));
1059 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
1060 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1061 RecordData Record;
1062 Record.push_back(MODULE_NAME);
1063 Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name);
1064 }
1065
1066 // Module map file
1067 if (WritingModule) {
1068 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1069 Abbrev->Add(BitCodeAbbrevOp(MODULE_MAP_FILE));
1070 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Filename
1071 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1072
1073 assert(WritingModule->ModuleMap && "missing module map");
1074 SmallString<128> ModuleMap(WritingModule->ModuleMap->getName());
1075 llvm::sys::fs::make_absolute(ModuleMap);
1076 RecordData Record;
1077 Record.push_back(MODULE_MAP_FILE);
1078 Stream.EmitRecordWithBlob(AbbrevCode, Record, ModuleMap.str());
1079 }
1080
Douglas Gregor112b9072012-10-18 05:31:06 +00001081 // Imports
Douglas Gregor29cc6422011-08-17 21:07:30 +00001082 if (Chain) {
Douglas Gregor29cc6422011-08-17 21:07:30 +00001083 serialization::ModuleManager &Mgr = Chain->getModuleManager();
Douglas Gregor29cc6422011-08-17 21:07:30 +00001084 Record.clear();
Douglas Gregordf0c1512011-08-18 04:12:04 +00001085
1086 for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end();
1087 M != MEnd; ++M) {
1088 // Skip modules that weren't directly imported.
1089 if (!(*M)->isDirectlyImported())
1090 continue;
1091
1092 Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding
Argyrios Kyrtzidis2ec29362012-11-15 18:57:22 +00001093 AddSourceLocation((*M)->ImportLoc, Record);
Douglas Gregor7029ce12013-03-19 00:28:20 +00001094 Record.push_back((*M)->File->getSize());
1095 Record.push_back((*M)->File->getModificationTime());
Douglas Gregordf0c1512011-08-18 04:12:04 +00001096 const std::string &FileName = (*M)->FileName;
1097 Record.push_back(FileName.size());
1098 Record.append(FileName.begin(), FileName.end());
1099 }
Douglas Gregor29cc6422011-08-17 21:07:30 +00001100 Stream.EmitRecord(IMPORTS, Record);
1101 }
Mike Stump11289f42009-09-09 15:08:12 +00001102
Douglas Gregor112b9072012-10-18 05:31:06 +00001103 // Language options.
1104 Record.clear();
1105 const LangOptions &LangOpts = Context.getLangOpts();
1106#define LANGOPT(Name, Bits, Default, Description) \
1107 Record.push_back(LangOpts.Name);
1108#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1109 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1110#include "clang/Basic/LangOptions.def"
Will Dietzf54319c2013-01-18 11:30:38 +00001111#define SANITIZER(NAME, ID) Record.push_back(LangOpts.Sanitize.ID);
1112#include "clang/Basic/Sanitizers.def"
Douglas Gregor112b9072012-10-18 05:31:06 +00001113
1114 Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind());
1115 AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record);
1116
1117 Record.push_back(LangOpts.CurrentModule.size());
1118 Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end());
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00001119
1120 // Comment options.
1121 Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size());
1122 for (CommentOptions::BlockCommandNamesTy::const_iterator
1123 I = LangOpts.CommentOpts.BlockCommandNames.begin(),
1124 IEnd = LangOpts.CommentOpts.BlockCommandNames.end();
1125 I != IEnd; ++I) {
1126 AddString(*I, Record);
1127 }
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00001128 Record.push_back(LangOpts.CommentOpts.ParseAllComments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00001129
Douglas Gregor112b9072012-10-18 05:31:06 +00001130 Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
1131
Douglas Gregor4d3611c2012-10-18 17:58:09 +00001132 // Target options.
1133 Record.clear();
Douglas Gregor0aa21c92012-10-18 18:27:37 +00001134 const TargetInfo &Target = Context.getTargetInfo();
1135 const TargetOptions &TargetOpts = Target.getTargetOpts();
Douglas Gregor4d3611c2012-10-18 17:58:09 +00001136 AddString(TargetOpts.Triple, Record);
1137 AddString(TargetOpts.CPU, Record);
1138 AddString(TargetOpts.ABI, Record);
Douglas Gregor4d3611c2012-10-18 17:58:09 +00001139 AddString(TargetOpts.LinkerVersion, Record);
1140 Record.push_back(TargetOpts.FeaturesAsWritten.size());
1141 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) {
1142 AddString(TargetOpts.FeaturesAsWritten[I], Record);
1143 }
1144 Record.push_back(TargetOpts.Features.size());
1145 for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) {
1146 AddString(TargetOpts.Features[I], Record);
1147 }
1148 Stream.EmitRecord(TARGET_OPTIONS, Record);
1149
Douglas Gregor8263ffb2012-10-24 15:17:15 +00001150 // Diagnostic options.
1151 Record.clear();
1152 const DiagnosticOptions &DiagOpts
1153 = Context.getDiagnostics().getDiagnosticOptions();
1154#define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1155#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1156 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1157#include "clang/Basic/DiagnosticOptions.def"
1158 Record.push_back(DiagOpts.Warnings.size());
1159 for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I)
1160 AddString(DiagOpts.Warnings[I], Record);
1161 // Note: we don't serialize the log or serialization file names, because they
1162 // are generally transient files and will almost always be overridden.
1163 Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record);
1164
Douglas Gregorc6317db2012-10-24 15:49:58 +00001165 // File system options.
1166 Record.clear();
1167 const FileSystemOptions &FSOpts
1168 = Context.getSourceManager().getFileManager().getFileSystemOptions();
1169 AddString(FSOpts.WorkingDir, Record);
1170 Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record);
1171
Douglas Gregor2d302362012-10-24 16:50:34 +00001172 // Header search options.
1173 Record.clear();
1174 const HeaderSearchOptions &HSOpts
1175 = PP.getHeaderSearchInfo().getHeaderSearchOpts();
1176 AddString(HSOpts.Sysroot, Record);
1177
1178 // Include entries.
1179 Record.push_back(HSOpts.UserEntries.size());
1180 for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
1181 const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I];
1182 AddString(Entry.Path, Record);
1183 Record.push_back(static_cast<unsigned>(Entry.Group));
Douglas Gregor2d302362012-10-24 16:50:34 +00001184 Record.push_back(Entry.IsFramework);
1185 Record.push_back(Entry.IgnoreSysRoot);
Douglas Gregor2d302362012-10-24 16:50:34 +00001186 }
1187
1188 // System header prefixes.
1189 Record.push_back(HSOpts.SystemHeaderPrefixes.size());
1190 for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
1191 AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record);
1192 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
1193 }
1194
1195 AddString(HSOpts.ResourceDir, Record);
1196 AddString(HSOpts.ModuleCachePath, Record);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00001197 AddString(HSOpts.ModuleUserBuildPath, Record);
Douglas Gregor2d302362012-10-24 16:50:34 +00001198 Record.push_back(HSOpts.DisableModuleHash);
1199 Record.push_back(HSOpts.UseBuiltinIncludes);
1200 Record.push_back(HSOpts.UseStandardSystemIncludes);
1201 Record.push_back(HSOpts.UseStandardCXXIncludes);
1202 Record.push_back(HSOpts.UseLibcxx);
1203 Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record);
1204
Douglas Gregorb6af6c22012-10-24 20:05:57 +00001205 // Preprocessor options.
1206 Record.clear();
1207 const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts();
1208
1209 // Macro definitions.
1210 Record.push_back(PPOpts.Macros.size());
1211 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
1212 AddString(PPOpts.Macros[I].first, Record);
1213 Record.push_back(PPOpts.Macros[I].second);
1214 }
1215
1216 // Includes
1217 Record.push_back(PPOpts.Includes.size());
1218 for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I)
1219 AddString(PPOpts.Includes[I], Record);
1220
1221 // Macro includes
1222 Record.push_back(PPOpts.MacroIncludes.size());
1223 for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I)
1224 AddString(PPOpts.MacroIncludes[I], Record);
1225
Douglas Gregorb6368752012-10-24 23:41:50 +00001226 Record.push_back(PPOpts.UsePredefines);
Argyrios Kyrtzidisd3afa0c2013-04-26 21:33:40 +00001227 // Detailed record is important since it is used for the module cache hash.
1228 Record.push_back(PPOpts.DetailedRecord);
Douglas Gregorb6af6c22012-10-24 20:05:57 +00001229 AddString(PPOpts.ImplicitPCHInclude, Record);
1230 AddString(PPOpts.ImplicitPTHInclude, Record);
1231 Record.push_back(static_cast<unsigned>(PPOpts.ObjCXXARCStandardLibrary));
1232 Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record);
1233
Douglas Gregora3b20262011-05-06 21:43:30 +00001234 // Original file name and file ID
Douglas Gregor45fe0362009-05-12 01:31:05 +00001235 SourceManager &SM = Context.getSourceManager();
1236 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1237 BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev();
Douglas Gregorfad10d82012-10-18 18:36:53 +00001238 FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE));
1239 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID
Douglas Gregor45fe0362009-05-12 01:31:05 +00001240 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1241 unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev);
1242
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00001243 SmallString<128> MainFilePath(MainFile->getName());
Mike Stump11289f42009-09-09 15:08:12 +00001244
Michael J. Spencer740857f2010-12-21 16:45:57 +00001245 llvm::sys::fs::make_absolute(MainFilePath);
Douglas Gregor45fe0362009-05-12 01:31:05 +00001246
Kovarththanan Rajaratnamd16d38c2010-03-14 07:15:57 +00001247 const char *MainFileNameStr = MainFilePath.c_str();
Mike Stump11289f42009-09-09 15:08:12 +00001248 MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr,
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001249 isysroot);
Douglas Gregorb6af6c22012-10-24 20:05:57 +00001250 Record.clear();
Douglas Gregorfad10d82012-10-18 18:36:53 +00001251 Record.push_back(ORIGINAL_FILE);
Douglas Gregora3b20262011-05-06 21:43:30 +00001252 Record.push_back(SM.getMainFileID().getOpaqueValue());
Douglas Gregorfad10d82012-10-18 18:36:53 +00001253 Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr);
Douglas Gregor45fe0362009-05-12 01:31:05 +00001254 }
Kovarththanan Rajaratnama9c81a82010-03-14 07:06:50 +00001255
Argyrios Kyrtzidis52595242012-11-15 18:57:27 +00001256 Record.clear();
1257 Record.push_back(SM.getMainFileID().getOpaqueValue());
1258 Stream.EmitRecord(ORIGINAL_FILE_ID, Record);
1259
Argyrios Kyrtzidis10b23682011-02-15 17:54:22 +00001260 // Original PCH directory
1261 if (!OutputFile.empty() && OutputFile != "-") {
1262 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1263 Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR));
1264 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1265 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1266
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00001267 SmallString<128> OutputPath(OutputFile);
Argyrios Kyrtzidis10b23682011-02-15 17:54:22 +00001268
1269 llvm::sys::fs::make_absolute(OutputPath);
1270 StringRef origDir = llvm::sys::path::parent_path(OutputPath);
1271
1272 RecordData Record;
1273 Record.push_back(ORIGINAL_PCH_DIR);
1274 Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
1275 }
1276
Douglas Gregor49491f72013-03-15 22:15:07 +00001277 WriteInputFiles(Context.SourceMgr,
1278 PP.getHeaderSearchInfo().getHeaderSearchOpts(),
Douglas Gregora3dd9002013-07-22 20:48:33 +00001279 isysroot,
1280 PP.getLangOpts().Modules);
Douglas Gregor72be3902012-10-19 00:38:02 +00001281 Stream.ExitBlock();
1282}
1283
Douglas Gregor49491f72013-03-15 22:15:07 +00001284namespace {
1285 /// \brief An input file.
1286 struct InputFileEntry {
1287 const FileEntry *File;
1288 bool IsSystemFile;
1289 bool BufferOverridden;
1290 };
1291}
1292
1293void ASTWriter::WriteInputFiles(SourceManager &SourceMgr,
1294 HeaderSearchOptions &HSOpts,
Douglas Gregora3dd9002013-07-22 20:48:33 +00001295 StringRef isysroot,
1296 bool Modules) {
Douglas Gregor72be3902012-10-19 00:38:02 +00001297 using namespace llvm;
1298 Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4);
1299 RecordData Record;
1300
1301 // Create input-file abbreviation.
1302 BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev();
1303 IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE));
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001304 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
Douglas Gregor72be3902012-10-19 00:38:02 +00001305 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
1306 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001307 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden
Douglas Gregor72be3902012-10-19 00:38:02 +00001308 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1309 unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev);
1310
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001311 // Get all ContentCache objects for files, sorted by whether the file is a
1312 // system one or not. System files go at the back, users files at the front.
Douglas Gregor49491f72013-03-15 22:15:07 +00001313 std::deque<InputFileEntry> SortedFiles;
Douglas Gregor72be3902012-10-19 00:38:02 +00001314 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) {
1315 // Get this source location entry.
1316 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
NAKAMURA Takumideca50f2012-10-19 01:53:57 +00001317 assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc);
Douglas Gregor72be3902012-10-19 00:38:02 +00001318
1319 // We only care about file entries that were not overridden.
1320 if (!SLoc->isFile())
1321 continue;
1322 const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001323 if (!Cache->OrigEntry)
Douglas Gregor72be3902012-10-19 00:38:02 +00001324 continue;
1325
Douglas Gregor49491f72013-03-15 22:15:07 +00001326 InputFileEntry Entry;
1327 Entry.File = Cache->OrigEntry;
1328 Entry.IsSystemFile = Cache->IsSystemFile;
1329 Entry.BufferOverridden = Cache->BufferOverridden;
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001330 if (Cache->IsSystemFile)
Douglas Gregor49491f72013-03-15 22:15:07 +00001331 SortedFiles.push_back(Entry);
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001332 else
Douglas Gregor49491f72013-03-15 22:15:07 +00001333 SortedFiles.push_front(Entry);
1334 }
1335
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001336 unsigned UserFilesNum = 0;
1337 // Write out all of the input files.
1338 std::vector<uint32_t> InputFileOffsets;
Douglas Gregor49491f72013-03-15 22:15:07 +00001339 for (std::deque<InputFileEntry>::iterator
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001340 I = SortedFiles.begin(), E = SortedFiles.end(); I != E; ++I) {
Douglas Gregor49491f72013-03-15 22:15:07 +00001341 const InputFileEntry &Entry = *I;
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001342
Douglas Gregor49491f72013-03-15 22:15:07 +00001343 uint32_t &InputFileID = InputFileIDs[Entry.File];
Argyrios Kyrtzidise65856f2012-12-11 07:48:08 +00001344 if (InputFileID != 0)
1345 continue; // already recorded this file.
1346
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001347 // Record this entry's offset.
1348 InputFileOffsets.push_back(Stream.GetCurrentBitNo());
Argyrios Kyrtzidise65856f2012-12-11 07:48:08 +00001349
1350 InputFileID = InputFileOffsets.size();
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001351
Douglas Gregor49491f72013-03-15 22:15:07 +00001352 if (!Entry.IsSystemFile)
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001353 ++UserFilesNum;
1354
Douglas Gregor72be3902012-10-19 00:38:02 +00001355 Record.clear();
1356 Record.push_back(INPUT_FILE);
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001357 Record.push_back(InputFileOffsets.size());
Douglas Gregor72be3902012-10-19 00:38:02 +00001358
1359 // Emit size/modification time for this file.
Douglas Gregor49491f72013-03-15 22:15:07 +00001360 Record.push_back(Entry.File->getSize());
1361 Record.push_back(Entry.File->getModificationTime());
Douglas Gregor72be3902012-10-19 00:38:02 +00001362
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001363 // Whether this file was overridden.
Douglas Gregor49491f72013-03-15 22:15:07 +00001364 Record.push_back(Entry.BufferOverridden);
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001365
Douglas Gregor72be3902012-10-19 00:38:02 +00001366 // Turn the file name into an absolute path, if it isn't already.
Douglas Gregor49491f72013-03-15 22:15:07 +00001367 const char *Filename = Entry.File->getName();
Douglas Gregor72be3902012-10-19 00:38:02 +00001368 SmallString<128> FilePath(Filename);
1369
1370 // Ask the file manager to fixup the relative path for us. This will
1371 // honor the working directory.
Ben Langmuircb69b572014-03-07 06:40:32 +00001372 SourceMgr.getFileManager().FixupRelativePath(FilePath);
Douglas Gregor72be3902012-10-19 00:38:02 +00001373
1374 // FIXME: This call to make_absolute shouldn't be necessary, the
1375 // call to FixupRelativePath should always return an absolute path.
1376 llvm::sys::fs::make_absolute(FilePath);
1377 Filename = FilePath.c_str();
1378
1379 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1380
1381 Stream.EmitRecordWithBlob(IFAbbrevCode, Record, Filename);
1382 }
Douglas Gregor49491f72013-03-15 22:15:07 +00001383
Douglas Gregor112b9072012-10-18 05:31:06 +00001384 Stream.ExitBlock();
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001385
1386 // Create input file offsets abbreviation.
1387 BitCodeAbbrev *OffsetsAbbrev = new BitCodeAbbrev();
1388 OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS));
1389 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001390 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system
1391 // input files
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001392 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array
1393 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev);
1394
1395 // Write input file offsets.
1396 Record.clear();
1397 Record.push_back(INPUT_FILE_OFFSETS);
1398 Record.push_back(InputFileOffsets.size());
Argyrios Kyrtzidis7d238572013-03-06 18:12:50 +00001399 Record.push_back(UserFilesNum);
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001400 Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, data(InputFileOffsets));
Douglas Gregor55abb232009-04-10 20:39:37 +00001401}
1402
Douglas Gregora7f71a92009-04-10 03:52:48 +00001403//===----------------------------------------------------------------------===//
1404// Source Manager Serialization
1405//===----------------------------------------------------------------------===//
1406
1407/// \brief Create an abbreviation for the SLocEntry that refers to a
1408/// file.
Douglas Gregor8f45df52009-04-16 22:23:12 +00001409static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
Douglas Gregora7f71a92009-04-10 03:52:48 +00001410 using namespace llvm;
1411 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00001412 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
Douglas Gregora7f71a92009-04-10 03:52:48 +00001413 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1414 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1415 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1416 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
Douglas Gregorb41ca8f2010-03-21 22:49:54 +00001417 // FileEntry fields.
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001418 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID
Argyrios Kyrtzidis61ef3db2011-08-21 23:33:04 +00001419 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00001420 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex
1421 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls
Douglas Gregor8f45df52009-04-16 22:23:12 +00001422 return Stream.EmitAbbrev(Abbrev);
Douglas Gregora7f71a92009-04-10 03:52:48 +00001423}
1424
1425/// \brief Create an abbreviation for the SLocEntry that refers to a
1426/// buffer.
Douglas Gregor8f45df52009-04-16 22:23:12 +00001427static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
Douglas Gregora7f71a92009-04-10 03:52:48 +00001428 using namespace llvm;
1429 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00001430 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
Douglas Gregora7f71a92009-04-10 03:52:48 +00001431 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1432 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1433 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1434 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1435 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
Douglas Gregor8f45df52009-04-16 22:23:12 +00001436 return Stream.EmitAbbrev(Abbrev);
Douglas Gregora7f71a92009-04-10 03:52:48 +00001437}
1438
1439/// \brief Create an abbreviation for the SLocEntry that refers to a
1440/// buffer's blob.
Douglas Gregor8f45df52009-04-16 22:23:12 +00001441static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) {
Douglas Gregora7f71a92009-04-10 03:52:48 +00001442 using namespace llvm;
1443 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00001444 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB));
Douglas Gregora7f71a92009-04-10 03:52:48 +00001445 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
Douglas Gregor8f45df52009-04-16 22:23:12 +00001446 return Stream.EmitAbbrev(Abbrev);
Douglas Gregora7f71a92009-04-10 03:52:48 +00001447}
1448
Chandler Carruthf92ac9e2011-07-15 07:25:21 +00001449/// \brief Create an abbreviation for the SLocEntry that refers to a macro
1450/// expansion.
1451static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) {
Douglas Gregora7f71a92009-04-10 03:52:48 +00001452 using namespace llvm;
1453 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Chandler Carruthf92ac9e2011-07-15 07:25:21 +00001454 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY));
Douglas Gregora7f71a92009-04-10 03:52:48 +00001455 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1456 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
1457 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
1458 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
Douglas Gregor83243272009-04-15 18:05:10 +00001459 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
Douglas Gregor8f45df52009-04-16 22:23:12 +00001460 return Stream.EmitAbbrev(Abbrev);
Douglas Gregora7f71a92009-04-10 03:52:48 +00001461}
1462
Douglas Gregor09b69892011-02-10 17:09:37 +00001463namespace {
1464 // Trait used for the on-disk hash table of header search information.
1465 class HeaderFileInfoTrait {
1466 ASTWriter &Writer;
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001467 const HeaderSearch &HS;
Douglas Gregor09b69892011-02-10 17:09:37 +00001468
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001469 // Keep track of the framework names we've used during serialization.
1470 SmallVector<char, 128> FrameworkStringData;
1471 llvm::StringMap<unsigned> FrameworkNameOffset;
1472
Douglas Gregor09b69892011-02-10 17:09:37 +00001473 public:
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001474 HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS)
1475 : Writer(Writer), HS(HS) { }
Douglas Gregor09b69892011-02-10 17:09:37 +00001476
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001477 struct key_type {
1478 const FileEntry *FE;
1479 const char *Filename;
1480 };
1481 typedef const key_type &key_type_ref;
Douglas Gregor09b69892011-02-10 17:09:37 +00001482
1483 typedef HeaderFileInfo data_type;
1484 typedef const data_type &data_type_ref;
Justin Bogner25463f12014-04-18 20:27:24 +00001485 typedef unsigned hash_value_type;
1486 typedef unsigned offset_type;
Douglas Gregor09b69892011-02-10 17:09:37 +00001487
Justin Bogner25463f12014-04-18 20:27:24 +00001488 static hash_value_type ComputeHash(key_type_ref key) {
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001489 // The hash is based only on size/time of the file, so that the reader can
1490 // match even when symlinking or excess path elements ("foo/../", "../")
1491 // change the form of the name. However, complete path is still the key.
1492 return llvm::hash_combine(key.FE->getSize(),
1493 key.FE->getModificationTime());
Douglas Gregor09b69892011-02-10 17:09:37 +00001494 }
1495
1496 std::pair<unsigned,unsigned>
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001497 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) {
Justin Bognere1c147c2014-03-28 22:03:19 +00001498 using namespace llvm::support;
1499 endian::Writer<little> Writer(Out);
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001500 unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8;
Justin Bognere1c147c2014-03-28 22:03:19 +00001501 Writer.write<uint16_t>(KeyLen);
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001502 unsigned DataLen = 1 + 2 + 4 + 4;
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001503 if (Data.isModuleHeader)
1504 DataLen += 4;
Justin Bognere1c147c2014-03-28 22:03:19 +00001505 Writer.write<uint8_t>(DataLen);
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001506 return std::make_pair(KeyLen, DataLen);
Douglas Gregor09b69892011-02-10 17:09:37 +00001507 }
1508
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001509 void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) {
Justin Bognere1c147c2014-03-28 22:03:19 +00001510 using namespace llvm::support;
1511 endian::Writer<little> LE(Out);
1512 LE.write<uint64_t>(key.FE->getSize());
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001513 KeyLen -= 8;
Justin Bognere1c147c2014-03-28 22:03:19 +00001514 LE.write<uint64_t>(key.FE->getModificationTime());
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001515 KeyLen -= 8;
1516 Out.write(key.Filename, KeyLen);
Douglas Gregor09b69892011-02-10 17:09:37 +00001517 }
1518
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001519 void EmitData(raw_ostream &Out, key_type_ref key,
Douglas Gregor09b69892011-02-10 17:09:37 +00001520 data_type_ref Data, unsigned DataLen) {
Justin Bognere1c147c2014-03-28 22:03:19 +00001521 using namespace llvm::support;
1522 endian::Writer<little> LE(Out);
Douglas Gregor09b69892011-02-10 17:09:37 +00001523 uint64_t Start = Out.tell(); (void)Start;
1524
Lawrence Crowlb53e5482013-06-20 21:14:14 +00001525 unsigned char Flags = (Data.HeaderRole << 6)
1526 | (Data.isImport << 5)
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001527 | (Data.isPragmaOnce << 4)
1528 | (Data.DirInfo << 2)
1529 | (Data.Resolved << 1)
1530 | Data.IndexHeaderMapHeader;
Justin Bognere1c147c2014-03-28 22:03:19 +00001531 LE.write<uint8_t>(Flags);
1532 LE.write<uint16_t>(Data.NumIncludes);
Douglas Gregor09b69892011-02-10 17:09:37 +00001533
1534 if (!Data.ControllingMacro)
Justin Bognere1c147c2014-03-28 22:03:19 +00001535 LE.write<uint32_t>(Data.ControllingMacroID);
Douglas Gregor09b69892011-02-10 17:09:37 +00001536 else
Justin Bognere1c147c2014-03-28 22:03:19 +00001537 LE.write<uint32_t>(Writer.getIdentifierRef(Data.ControllingMacro));
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001538
1539 unsigned Offset = 0;
1540 if (!Data.Framework.empty()) {
1541 // If this header refers into a framework, save the framework name.
1542 llvm::StringMap<unsigned>::iterator Pos
1543 = FrameworkNameOffset.find(Data.Framework);
1544 if (Pos == FrameworkNameOffset.end()) {
1545 Offset = FrameworkStringData.size() + 1;
1546 FrameworkStringData.append(Data.Framework.begin(),
1547 Data.Framework.end());
1548 FrameworkStringData.push_back(0);
1549
1550 FrameworkNameOffset[Data.Framework] = Offset;
1551 } else
1552 Offset = Pos->second;
1553 }
Justin Bognere1c147c2014-03-28 22:03:19 +00001554 LE.write<uint32_t>(Offset);
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001555
1556 if (Data.isModuleHeader) {
Lawrence Crowlb53e5482013-06-20 21:14:14 +00001557 Module *Mod = HS.findModuleForHeader(key.FE).getModule();
Justin Bognere1c147c2014-03-28 22:03:19 +00001558 LE.write<uint32_t>(Writer.getExistingSubmoduleID(Mod));
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001559 }
1560
Douglas Gregor09b69892011-02-10 17:09:37 +00001561 assert(Out.tell() - Start == DataLen && "Wrong data length");
1562 }
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001563
1564 const char *strings_begin() const { return FrameworkStringData.begin(); }
1565 const char *strings_end() const { return FrameworkStringData.end(); }
Douglas Gregor09b69892011-02-10 17:09:37 +00001566 };
1567} // end anonymous namespace
1568
1569/// \brief Write the header search block for the list of files that
1570///
1571/// \param HS The header search structure to save.
Argyrios Kyrtzidisf5ab0342011-11-13 22:08:39 +00001572void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001573 SmallVector<const FileEntry *, 16> FilesByUID;
Douglas Gregor09b69892011-02-10 17:09:37 +00001574 HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
1575
1576 if (FilesByUID.size() > HS.header_file_size())
1577 FilesByUID.resize(HS.header_file_size());
1578
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001579 HeaderFileInfoTrait GeneratorTrait(*this, HS);
Justin Bognerbb094f02014-04-18 19:57:06 +00001580 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001581 SmallVector<const char *, 4> SavedStrings;
Douglas Gregor09b69892011-02-10 17:09:37 +00001582 unsigned NumHeaderSearchEntries = 0;
1583 for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
1584 const FileEntry *File = FilesByUID[UID];
1585 if (!File)
1586 continue;
1587
Argyrios Kyrtzidisf5ab0342011-11-13 22:08:39 +00001588 // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo
1589 // from the external source if it was not provided already.
Ben Langmuird285c502014-03-13 16:46:36 +00001590 HeaderFileInfo HFI;
1591 if (!HS.tryGetFileInfo(File, HFI) ||
1592 (HFI.External && Chain) ||
1593 (HFI.isModuleHeader && !HFI.isCompilingModuleHeader))
Argyrios Kyrtzidis6f722b42013-05-08 23:46:46 +00001594 continue;
Douglas Gregor09b69892011-02-10 17:09:37 +00001595
1596 // Turn the file name into an absolute path, if it isn't already.
1597 const char *Filename = File->getName();
1598 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1599
1600 // If we performed any translation on the file name at all, we need to
1601 // save this string, since the generator will refer to it later.
1602 if (Filename != File->getName()) {
1603 Filename = strdup(Filename);
1604 SavedStrings.push_back(Filename);
1605 }
1606
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001607 HeaderFileInfoTrait::key_type key = { File, Filename };
1608 Generator.insert(key, HFI, GeneratorTrait);
Douglas Gregor09b69892011-02-10 17:09:37 +00001609 ++NumHeaderSearchEntries;
1610 }
1611
1612 // Create the on-disk hash table in a buffer.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00001613 SmallString<4096> TableData;
Douglas Gregor09b69892011-02-10 17:09:37 +00001614 uint32_t BucketOffset;
1615 {
Justin Bognere1c147c2014-03-28 22:03:19 +00001616 using namespace llvm::support;
Douglas Gregor09b69892011-02-10 17:09:37 +00001617 llvm::raw_svector_ostream Out(TableData);
1618 // Make sure that no bucket is at offset 0
Justin Bognere1c147c2014-03-28 22:03:19 +00001619 endian::Writer<little>(Out).write<uint32_t>(0);
Douglas Gregor09b69892011-02-10 17:09:37 +00001620 BucketOffset = Generator.Emit(Out, GeneratorTrait);
1621 }
1622
1623 // Create a blob abbreviation
1624 using namespace llvm;
1625 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1626 Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
1627 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1628 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001629 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Douglas Gregor09b69892011-02-10 17:09:37 +00001630 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1631 unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev);
1632
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001633 // Write the header search table
Douglas Gregor09b69892011-02-10 17:09:37 +00001634 RecordData Record;
1635 Record.push_back(HEADER_SEARCH_TABLE);
1636 Record.push_back(BucketOffset);
1637 Record.push_back(NumHeaderSearchEntries);
Douglas Gregor4b123cb2011-07-28 04:50:02 +00001638 Record.push_back(TableData.size());
1639 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
Douglas Gregor09b69892011-02-10 17:09:37 +00001640 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str());
1641
1642 // Free all of the strings we had to duplicate.
1643 for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
David Greenebae0e352013-01-15 22:09:43 +00001644 free(const_cast<char *>(SavedStrings[I]));
Douglas Gregor09b69892011-02-10 17:09:37 +00001645}
1646
Douglas Gregora7f71a92009-04-10 03:52:48 +00001647/// \brief Writes the block containing the serialized form of the
1648/// source manager.
1649///
1650/// TODO: We should probably use an on-disk hash table (stored in a
1651/// blob), indexed based on the file name, so that we only create
1652/// entries for files that we actually need. In the common case (no
1653/// errors), we probably won't have to create file entries for any of
1654/// the files in the AST.
Sebastian Redl55c0ad52010-08-18 23:56:21 +00001655void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
Douglas Gregor0086a5a2009-07-07 00:12:59 +00001656 const Preprocessor &PP,
Douglas Gregorc567ba22011-07-22 16:35:34 +00001657 StringRef isysroot) {
Douglas Gregor258ae542009-04-27 06:38:32 +00001658 RecordData Record;
1659
Chris Lattner0910e3b2009-04-10 17:16:57 +00001660 // Enter the source manager block.
Sebastian Redl539c5062010-08-18 23:57:32 +00001661 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3);
Douglas Gregora7f71a92009-04-10 03:52:48 +00001662
1663 // Abbreviations for the various kinds of source-location entries.
Chris Lattnerc4976c732009-04-27 19:03:22 +00001664 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
1665 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
1666 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream);
Chandler Carruthf92ac9e2011-07-15 07:25:21 +00001667 unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
Douglas Gregora7f71a92009-04-10 03:52:48 +00001668
Douglas Gregor258ae542009-04-27 06:38:32 +00001669 // Write out the source location entry table. We skip the first
1670 // entry, which is always the same dummy entry.
Chris Lattner12d61d32009-04-27 19:01:47 +00001671 std::vector<uint32_t> SLocEntryOffsets;
Douglas Gregor258ae542009-04-27 06:38:32 +00001672 RecordData PreloadSLocs;
Douglas Gregor925296b2011-07-19 16:10:42 +00001673 SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
1674 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
Sebastian Redl5c415f32010-07-22 17:01:13 +00001675 I != N; ++I) {
Douglas Gregor8655e882009-10-16 22:46:09 +00001676 // Get this source location entry.
Douglas Gregor925296b2011-07-19 16:10:42 +00001677 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
Argyrios Kyrtzidis4db774a2012-10-02 21:09:17 +00001678 FileID FID = FileID::get(I);
1679 assert(&SourceMgr.getSLocEntry(FID) == SLoc);
Kovarththanan Rajaratnama9c81a82010-03-14 07:06:50 +00001680
Douglas Gregor258ae542009-04-27 06:38:32 +00001681 // Record the offset of this source-location entry.
1682 SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
1683
1684 // Figure out which record code to use.
1685 unsigned Code;
1686 if (SLoc->isFile()) {
Douglas Gregor9dc32122011-11-16 20:05:18 +00001687 const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
1688 if (Cache->OrigEntry) {
Sebastian Redl539c5062010-08-18 23:57:32 +00001689 Code = SM_SLOC_FILE_ENTRY;
Argyrios Kyrtzidis92dd4662011-06-02 20:01:46 +00001690 } else
Sebastian Redl539c5062010-08-18 23:57:32 +00001691 Code = SM_SLOC_BUFFER_ENTRY;
Douglas Gregor258ae542009-04-27 06:38:32 +00001692 } else
Chandler Carruthf92ac9e2011-07-15 07:25:21 +00001693 Code = SM_SLOC_EXPANSION_ENTRY;
Douglas Gregor258ae542009-04-27 06:38:32 +00001694 Record.clear();
1695 Record.push_back(Code);
1696
Douglas Gregor925296b2011-07-19 16:10:42 +00001697 // Starting offset of this entry within this module, so skip the dummy.
1698 Record.push_back(SLoc->getOffset() - 2);
Douglas Gregor258ae542009-04-27 06:38:32 +00001699 if (SLoc->isFile()) {
1700 const SrcMgr::FileInfo &File = SLoc->getFile();
1701 Record.push_back(File.getIncludeLoc().getRawEncoding());
1702 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding
1703 Record.push_back(File.hasLineDirectives());
1704
1705 const SrcMgr::ContentCache *Content = File.getContentCache();
Argyrios Kyrtzidis11e6f0a2011-03-05 01:03:53 +00001706 if (Content->OrigEntry) {
1707 assert(Content->OrigEntry == Content->ContentsEntry &&
Douglas Gregor9dc32122011-11-16 20:05:18 +00001708 "Writing to AST an overridden file is not supported");
Argyrios Kyrtzidis11e6f0a2011-03-05 01:03:53 +00001709
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001710 // The source location entry is a file. Emit input file ID.
1711 assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry");
1712 Record.push_back(InputFileIDs[Content->OrigEntry]);
Mike Stump11289f42009-09-09 15:08:12 +00001713
Argyrios Kyrtzidis61ef3db2011-08-21 23:33:04 +00001714 Record.push_back(File.NumCreatedFIDs);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00001715
Argyrios Kyrtzidis4db774a2012-10-02 21:09:17 +00001716 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00001717 if (FDI != FileDeclIDs.end()) {
1718 Record.push_back(FDI->second->FirstDeclIndex);
1719 Record.push_back(FDI->second->DeclIDs.size());
1720 } else {
1721 Record.push_back(0);
1722 Record.push_back(0);
1723 }
Douglas Gregor9dc32122011-11-16 20:05:18 +00001724
Douglas Gregor3120d2c2012-10-22 18:42:04 +00001725 Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record);
Douglas Gregor9dc32122011-11-16 20:05:18 +00001726
1727 if (Content->BufferOverridden) {
1728 Record.clear();
1729 Record.push_back(SM_SLOC_BUFFER_BLOB);
1730 const llvm::MemoryBuffer *Buffer
1731 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
1732 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
1733 StringRef(Buffer->getBufferStart(),
1734 Buffer->getBufferSize() + 1));
1735 }
Douglas Gregor258ae542009-04-27 06:38:32 +00001736 } else {
1737 // The source location entry is a buffer. The blob associated
1738 // with this entry contains the contents of the buffer.
1739
1740 // We add one to the size so that we capture the trailing NULL
1741 // that is required by llvm::MemoryBuffer::getMemBuffer (on
1742 // the reader side).
Douglas Gregor874cc622010-03-16 00:35:39 +00001743 const llvm::MemoryBuffer *Buffer
Chris Lattnerfb24a3a2010-04-20 20:35:58 +00001744 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
Douglas Gregor258ae542009-04-27 06:38:32 +00001745 const char *Name = Buffer->getBufferIdentifier();
Daniel Dunbar8100d012009-08-24 09:31:37 +00001746 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001747 StringRef(Name, strlen(Name) + 1));
Douglas Gregor258ae542009-04-27 06:38:32 +00001748 Record.clear();
Sebastian Redl539c5062010-08-18 23:57:32 +00001749 Record.push_back(SM_SLOC_BUFFER_BLOB);
Douglas Gregor258ae542009-04-27 06:38:32 +00001750 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001751 StringRef(Buffer->getBufferStart(),
Daniel Dunbar8100d012009-08-24 09:31:37 +00001752 Buffer->getBufferSize() + 1));
Douglas Gregor258ae542009-04-27 06:38:32 +00001753
Douglas Gregor925296b2011-07-19 16:10:42 +00001754 if (strcmp(Name, "<built-in>") == 0) {
1755 PreloadSLocs.push_back(SLocEntryOffsets.size());
1756 }
Douglas Gregor258ae542009-04-27 06:38:32 +00001757 }
1758 } else {
Chandler Carruthf92ac9e2011-07-15 07:25:21 +00001759 // The source location entry is a macro expansion.
Chandler Carruthee4c1d12011-07-26 04:56:51 +00001760 const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
Chandler Carruth73ee5d72011-07-26 04:41:47 +00001761 Record.push_back(Expansion.getSpellingLoc().getRawEncoding());
1762 Record.push_back(Expansion.getExpansionLocStart().getRawEncoding());
Argyrios Kyrtzidisa1d943a2011-08-17 00:31:14 +00001763 Record.push_back(Expansion.isMacroArgExpansion() ? 0
1764 : Expansion.getExpansionLocEnd().getRawEncoding());
Douglas Gregor258ae542009-04-27 06:38:32 +00001765
1766 // Compute the token length for this macro expansion.
Douglas Gregor925296b2011-07-19 16:10:42 +00001767 unsigned NextOffset = SourceMgr.getNextLocalOffset();
Douglas Gregor8655e882009-10-16 22:46:09 +00001768 if (I + 1 != N)
Douglas Gregor925296b2011-07-19 16:10:42 +00001769 NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
Douglas Gregor258ae542009-04-27 06:38:32 +00001770 Record.push_back(NextOffset - SLoc->getOffset() - 1);
Chandler Carruthf92ac9e2011-07-15 07:25:21 +00001771 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
Douglas Gregor258ae542009-04-27 06:38:32 +00001772 }
1773 }
1774
Douglas Gregor8f45df52009-04-16 22:23:12 +00001775 Stream.ExitBlock();
Douglas Gregor258ae542009-04-27 06:38:32 +00001776
1777 if (SLocEntryOffsets.empty())
1778 return;
1779
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001780 // Write the source-location offsets table into the AST block. This
Douglas Gregor258ae542009-04-27 06:38:32 +00001781 // table is used for lazily loading source-location information.
1782 using namespace llvm;
1783 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00001784 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
Douglas Gregor258ae542009-04-27 06:38:32 +00001785 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
Douglas Gregor925296b2011-07-19 16:10:42 +00001786 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
Douglas Gregor258ae542009-04-27 06:38:32 +00001787 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
1788 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
Mike Stump11289f42009-09-09 15:08:12 +00001789
Douglas Gregor258ae542009-04-27 06:38:32 +00001790 Record.clear();
Sebastian Redl539c5062010-08-18 23:57:32 +00001791 Record.push_back(SOURCE_LOCATION_OFFSETS);
Douglas Gregor258ae542009-04-27 06:38:32 +00001792 Record.push_back(SLocEntryOffsets.size());
Douglas Gregor925296b2011-07-19 16:10:42 +00001793 Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy
Benjamin Kramerd47a12a2011-04-24 17:44:50 +00001794 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets));
Douglas Gregor258ae542009-04-27 06:38:32 +00001795
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001796 // Write the source location entry preloads array, telling the AST
Douglas Gregor258ae542009-04-27 06:38:32 +00001797 // reader which source locations entries it should load eagerly.
Sebastian Redl539c5062010-08-18 23:57:32 +00001798 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
Douglas Gregor925296b2011-07-19 16:10:42 +00001799
1800 // Write the line table. It depends on remapping working, so it must come
1801 // after the source location offsets.
1802 if (SourceMgr.hasLineTable()) {
1803 LineTableInfo &LineTable = SourceMgr.getLineTable();
1804
1805 Record.clear();
1806 // Emit the file names
1807 Record.push_back(LineTable.getNumFilenames());
1808 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) {
1809 // Emit the file name
1810 const char *Filename = LineTable.getFilename(I);
1811 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1812 unsigned FilenameLen = Filename? strlen(Filename) : 0;
1813 Record.push_back(FilenameLen);
1814 if (FilenameLen)
1815 Record.insert(Record.end(), Filename, Filename + FilenameLen);
1816 }
1817
1818 // Emit the line entries
1819 for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end();
1820 L != LEnd; ++L) {
1821 // Only emit entries for local files.
Douglas Gregor02c2dbf2012-06-08 16:40:28 +00001822 if (L->first.ID < 0)
Douglas Gregor925296b2011-07-19 16:10:42 +00001823 continue;
1824
1825 // Emit the file ID
Douglas Gregor02c2dbf2012-06-08 16:40:28 +00001826 Record.push_back(L->first.ID);
Douglas Gregor925296b2011-07-19 16:10:42 +00001827
1828 // Emit the line entries
1829 Record.push_back(L->second.size());
1830 for (std::vector<LineEntry>::iterator LE = L->second.begin(),
1831 LEEnd = L->second.end();
1832 LE != LEEnd; ++LE) {
1833 Record.push_back(LE->FileOffset);
1834 Record.push_back(LE->LineNo);
1835 Record.push_back(LE->FilenameID);
1836 Record.push_back((unsigned)LE->FileKind);
1837 Record.push_back(LE->IncludeOffset);
1838 }
1839 }
1840 Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record);
1841 }
Douglas Gregora7f71a92009-04-10 03:52:48 +00001842}
1843
Douglas Gregorc5046832009-04-27 18:38:38 +00001844//===----------------------------------------------------------------------===//
1845// Preprocessor Serialization
1846//===----------------------------------------------------------------------===//
1847
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001848namespace {
1849class ASTMacroTableTrait {
1850public:
1851 typedef IdentID key_type;
1852 typedef key_type key_type_ref;
1853
1854 struct Data {
1855 uint32_t MacroDirectivesOffset;
1856 };
1857
1858 typedef Data data_type;
1859 typedef const data_type &data_type_ref;
Justin Bogner25463f12014-04-18 20:27:24 +00001860 typedef unsigned hash_value_type;
1861 typedef unsigned offset_type;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001862
Justin Bogner25463f12014-04-18 20:27:24 +00001863 static hash_value_type ComputeHash(IdentID IdID) {
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001864 return llvm::hash_value(IdID);
1865 }
1866
1867 std::pair<unsigned,unsigned>
1868 static EmitKeyDataLength(raw_ostream& Out,
1869 key_type_ref Key, data_type_ref Data) {
1870 unsigned KeyLen = 4; // IdentID.
1871 unsigned DataLen = 4; // MacroDirectivesOffset.
1872 return std::make_pair(KeyLen, DataLen);
1873 }
1874
1875 static void EmitKey(raw_ostream& Out, key_type_ref Key, unsigned KeyLen) {
Justin Bognere1c147c2014-03-28 22:03:19 +00001876 using namespace llvm::support;
1877 endian::Writer<little>(Out).write<uint32_t>(Key);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001878 }
1879
1880 static void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data,
1881 unsigned) {
Justin Bognere1c147c2014-03-28 22:03:19 +00001882 using namespace llvm::support;
1883 endian::Writer<little>(Out).write<uint32_t>(Data.MacroDirectivesOffset);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001884 }
1885};
1886} // end anonymous namespace
1887
Benjamin Kramer04bf1872013-09-22 14:10:29 +00001888static int compareMacroDirectives(
1889 const std::pair<const IdentifierInfo *, MacroDirective *> *X,
1890 const std::pair<const IdentifierInfo *, MacroDirective *> *Y) {
1891 return X->first->getName().compare(Y->first->getName());
Douglas Gregor2e5571d2011-02-10 18:20:09 +00001892}
1893
Argyrios Kyrtzidis0aef0f02013-03-15 22:43:10 +00001894static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule,
1895 const Preprocessor &PP) {
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00001896 if (MacroInfo *MI = MD->getMacroInfo())
1897 if (MI->isBuiltinMacro())
1898 return true;
Argyrios Kyrtzidis0aef0f02013-03-15 22:43:10 +00001899
1900 if (IsModule) {
1901 SourceLocation Loc = MD->getLocation();
1902 if (Loc.isInvalid())
1903 return true;
1904 if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID())
1905 return true;
1906 }
1907
1908 return false;
1909}
1910
Chris Lattnereeffaef2009-04-10 17:15:23 +00001911/// \brief Writes the block containing the serialized form of the
1912/// preprocessor.
1913///
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00001914void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00001915 PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
1916 if (PPRec)
1917 WritePreprocessorDetail(*PPRec);
1918
Chris Lattnerbaa52f42009-04-10 18:00:12 +00001919 RecordData Record;
Chris Lattner0910e3b2009-04-10 17:16:57 +00001920
Chris Lattner0af3ba12009-04-13 01:29:17 +00001921 // If the preprocessor __COUNTER__ value has been bumped, remember it.
1922 if (PP.getCounterValue() != 0) {
1923 Record.push_back(PP.getCounterValue());
Sebastian Redl539c5062010-08-18 23:57:32 +00001924 Stream.EmitRecord(PP_COUNTER_VALUE, Record);
Chris Lattner0af3ba12009-04-13 01:29:17 +00001925 Record.clear();
Douglas Gregoreda6a892009-04-26 00:07:37 +00001926 }
1927
1928 // Enter the preprocessor block.
Douglas Gregor796d76a2010-10-20 22:00:55 +00001929 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3);
Mike Stump11289f42009-09-09 15:08:12 +00001930
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001931 // If the AST file contains __DATE__ or __TIME__ emit a warning about this.
Douglas Gregoreda6a892009-04-26 00:07:37 +00001932 // FIXME: use diagnostics subsystem for localization etc.
1933 if (PP.SawDateOrTime())
1934 fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n");
Mike Stump11289f42009-09-09 15:08:12 +00001935
Douglas Gregor796d76a2010-10-20 22:00:55 +00001936
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001937 // Loop over all the macro directives that are live at the end of the file,
Chris Lattnerbaa52f42009-04-10 18:00:12 +00001938 // emitting each to the PP section.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001939
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001940 // Construct the list of macro directives that need to be serialized.
Argyrios Kyrtzidis09c9e812013-02-20 00:54:57 +00001941 SmallVector<std::pair<const IdentifierInfo *, MacroDirective *>, 2>
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001942 MacroDirectives;
1943 for (Preprocessor::macro_iterator
1944 I = PP.macro_begin(/*IncludeExternalMacros=*/false),
1945 E = PP.macro_end(/*IncludeExternalMacros=*/false);
Chris Lattnerbaa52f42009-04-10 18:00:12 +00001946 I != E; ++I) {
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001947 MacroDirectives.push_back(std::make_pair(I->first, I->second));
Douglas Gregor2e5571d2011-02-10 18:20:09 +00001948 }
Alexander Kornienko1d26c022012-09-25 17:18:14 +00001949
Douglas Gregor2e5571d2011-02-10 18:20:09 +00001950 // Sort the set of macro definitions that need to be serialized by the
1951 // name of the macro, to provide a stable ordering.
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001952 llvm::array_pod_sort(MacroDirectives.begin(), MacroDirectives.end(),
1953 &compareMacroDirectives);
1954
Justin Bognerbb094f02014-04-18 19:57:06 +00001955 llvm::OnDiskChainedHashTableGenerator<ASTMacroTableTrait> Generator;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001956
1957 // Emit the macro directives as a list and associate the offset with the
1958 // identifier they belong to.
1959 for (unsigned I = 0, N = MacroDirectives.size(); I != N; ++I) {
1960 const IdentifierInfo *Name = MacroDirectives[I].first;
1961 uint64_t MacroDirectiveOffset = Stream.GetCurrentBitNo();
1962 MacroDirective *MD = MacroDirectives[I].second;
1963
1964 // If the macro or identifier need no updates, don't write the macro history
1965 // for this one.
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00001966 // FIXME: Chain the macro history instead of re-writing it.
1967 if (MD->isFromPCH() &&
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001968 Name->isFromAST() && !Name->hasChangedSinceDeserialization())
1969 continue;
1970
1971 // Emit the macro directives in reverse source order.
1972 for (; MD; MD = MD->getPrevious()) {
1973 if (shouldIgnoreMacro(MD, IsModule, PP))
1974 continue;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001975
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001976 AddSourceLocation(MD->getLocation(), Record);
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00001977 Record.push_back(MD->getKind());
1978 if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) {
1979 MacroID InfoID = getMacroRef(DefMD->getInfo(), Name);
1980 Record.push_back(InfoID);
1981 Record.push_back(DefMD->isImported());
1982 Record.push_back(DefMD->isAmbiguous());
1983
1984 } else if (VisibilityMacroDirective *
1985 VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
1986 Record.push_back(VisMD->isPublic());
1987 }
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001988 }
1989 if (Record.empty())
1990 continue;
1991
1992 Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record);
1993 Record.clear();
1994
1995 IdentMacroDirectivesOffsetMap[Name] = MacroDirectiveOffset;
1996
1997 IdentID NameID = getIdentifierRef(Name);
1998 ASTMacroTableTrait::Data data;
1999 data.MacroDirectivesOffset = MacroDirectiveOffset;
2000 Generator.insert(NameID, data);
2001 }
Alexander Kornienko1d26c022012-09-25 17:18:14 +00002002
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00002003 /// \brief Offsets of each of the macros into the bitstream, indexed by
2004 /// the local macro ID
2005 ///
2006 /// For each identifier that is associated with a macro, this map
2007 /// provides the offset into the bitstream where that macro is
2008 /// defined.
2009 std::vector<uint32_t> MacroOffsets;
2010
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002011 for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2012 const IdentifierInfo *Name = MacroInfosToEmit[I].Name;
2013 MacroInfo *MI = MacroInfosToEmit[I].MI;
2014 MacroID ID = MacroInfosToEmit[I].ID;
Douglas Gregoreb114da2010-10-01 01:03:07 +00002015
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002016 if (ID < FirstMacroID) {
2017 assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?");
2018 continue;
Chris Lattner2199f5b2009-04-10 18:08:30 +00002019 }
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002020
2021 // Record the local offset of this macro.
2022 unsigned Index = ID - FirstMacroID;
2023 if (Index == MacroOffsets.size())
2024 MacroOffsets.push_back(Stream.GetCurrentBitNo());
2025 else {
2026 if (Index > MacroOffsets.size())
2027 MacroOffsets.resize(Index + 1);
2028
2029 MacroOffsets[Index] = Stream.GetCurrentBitNo();
2030 }
2031
2032 AddIdentifierRef(Name, Record);
2033 Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc()));
2034 AddSourceLocation(MI->getDefinitionLoc(), Record);
2035 AddSourceLocation(MI->getDefinitionEndLoc(), Record);
2036 Record.push_back(MI->isUsed());
Argyrios Kyrtzidis9ef53ce2014-04-09 18:21:23 +00002037 Record.push_back(MI->isUsedForHeaderGuard());
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002038 unsigned Code;
2039 if (MI->isObjectLike()) {
2040 Code = PP_MACRO_OBJECT_LIKE;
2041 } else {
2042 Code = PP_MACRO_FUNCTION_LIKE;
2043
2044 Record.push_back(MI->isC99Varargs());
2045 Record.push_back(MI->isGNUVarargs());
2046 Record.push_back(MI->hasCommaPasting());
2047 Record.push_back(MI->getNumArgs());
2048 for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
2049 I != E; ++I)
2050 AddIdentifierRef(*I, Record);
2051 }
2052
2053 // If we have a detailed preprocessing record, record the macro definition
2054 // ID that corresponds to this macro.
2055 if (PPRec)
2056 Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]);
2057
2058 Stream.EmitRecord(Code, Record);
2059 Record.clear();
2060
2061 // Emit the tokens array.
2062 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) {
2063 // Note that we know that the preprocessor does not have any annotation
2064 // tokens in it because they are created by the parser, and thus can't
2065 // be in a macro definition.
2066 const Token &Tok = MI->getReplacementToken(TokNo);
John McCallf413f5e2013-05-03 00:10:13 +00002067 AddToken(Tok, Record);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002068 Stream.EmitRecord(PP_TOKEN, Record);
2069 Record.clear();
2070 }
2071 ++NumMacros;
Chris Lattnerbaa52f42009-04-10 18:00:12 +00002072 }
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002073
Douglas Gregor92a96f52011-02-08 21:58:10 +00002074 Stream.ExitBlock();
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00002075
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002076 // Create the on-disk hash table in a buffer.
2077 SmallString<4096> MacroTable;
2078 uint32_t BucketOffset;
2079 {
Justin Bognere1c147c2014-03-28 22:03:19 +00002080 using namespace llvm::support;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002081 llvm::raw_svector_ostream Out(MacroTable);
2082 // Make sure that no bucket is at offset 0
Justin Bognere1c147c2014-03-28 22:03:19 +00002083 endian::Writer<little>(Out).write<uint32_t>(0);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002084 BucketOffset = Generator.Emit(Out);
2085 }
2086
2087 // Write the macro table
2088 using namespace llvm;
2089 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2090 Abbrev->Add(BitCodeAbbrevOp(MACRO_TABLE));
2091 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2092 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2093 unsigned MacroTableAbbrev = Stream.EmitAbbrev(Abbrev);
2094
2095 Record.push_back(MACRO_TABLE);
2096 Record.push_back(BucketOffset);
2097 Stream.EmitRecordWithBlob(MacroTableAbbrev, Record, MacroTable.str());
2098 Record.clear();
2099
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00002100 // Write the offsets table for macro IDs.
2101 using namespace llvm;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002102 Abbrev = new BitCodeAbbrev();
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00002103 Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET));
2104 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros
2105 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
2106 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2107
2108 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2109 Record.clear();
2110 Record.push_back(MACRO_OFFSET);
2111 Record.push_back(MacroOffsets.size());
2112 Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS);
2113 Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record,
2114 data(MacroOffsets));
Douglas Gregor92a96f52011-02-08 21:58:10 +00002115}
2116
2117void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
Argyrios Kyrtzidis7f448362011-09-19 20:40:42 +00002118 if (PPRec.local_begin() == PPRec.local_end())
Douglas Gregor92a96f52011-02-08 21:58:10 +00002119 return;
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002120
Argyrios Kyrtzidis64f63812011-09-19 20:40:25 +00002121 SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002122
Douglas Gregor92a96f52011-02-08 21:58:10 +00002123 // Enter the preprocessor block.
2124 Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002125
Douglas Gregoraae92242010-03-19 21:51:54 +00002126 // If the preprocessor has a preprocessing record, emit it.
2127 unsigned NumPreprocessingRecords = 0;
Douglas Gregor92a96f52011-02-08 21:58:10 +00002128 using namespace llvm;
2129
2130 // Set up the abbreviation for
2131 unsigned InclusionAbbrev = 0;
2132 {
2133 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2134 Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE));
Douglas Gregor92a96f52011-02-08 21:58:10 +00002135 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
2136 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
2137 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
Argyrios Kyrtzidisf590e092012-10-02 16:10:46 +00002138 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module
Douglas Gregor92a96f52011-02-08 21:58:10 +00002139 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2140 InclusionAbbrev = Stream.EmitAbbrev(Abbrev);
2141 }
2142
Douglas Gregor2f555fc2011-08-04 18:56:47 +00002143 unsigned FirstPreprocessorEntityID
2144 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2145 + NUM_PREDEF_PP_ENTITY_IDS;
2146 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
Douglas Gregor92a96f52011-02-08 21:58:10 +00002147 RecordData Record;
Argyrios Kyrtzidis7f448362011-09-19 20:40:42 +00002148 for (PreprocessingRecord::iterator E = PPRec.local_begin(),
2149 EEnd = PPRec.local_end();
Douglas Gregor0d4b4312011-08-04 17:06:18 +00002150 E != EEnd;
2151 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
Douglas Gregor92a96f52011-02-08 21:58:10 +00002152 Record.clear();
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002153
Argyrios Kyrtzidis64f63812011-09-19 20:40:25 +00002154 PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(),
2155 Stream.GetCurrentBitNo()));
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002156
Douglas Gregor92a96f52011-02-08 21:58:10 +00002157 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) {
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002158 // Record this macro definition's ID.
2159 MacroDefinitions[MD] = NextPreprocessorEntityID;
Douglas Gregor92a96f52011-02-08 21:58:10 +00002160
Douglas Gregor92a96f52011-02-08 21:58:10 +00002161 AddIdentifierRef(MD->getName(), Record);
Douglas Gregor92a96f52011-02-08 21:58:10 +00002162 Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
2163 continue;
Douglas Gregoraae92242010-03-19 21:51:54 +00002164 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002165
Chandler Carrutha88a22182011-07-14 08:20:46 +00002166 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(*E)) {
Argyrios Kyrtzidis80f78b92011-09-08 17:18:41 +00002167 Record.push_back(ME->isBuiltinMacro());
2168 if (ME->isBuiltinMacro())
2169 AddIdentifierRef(ME->getName(), Record);
2170 else
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002171 Record.push_back(MacroDefinitions[ME->getDefinition()]);
Chandler Carruthf92ac9e2011-07-15 07:25:21 +00002172 Stream.EmitRecord(PPD_MACRO_EXPANSION, Record);
Douglas Gregor92a96f52011-02-08 21:58:10 +00002173 continue;
2174 }
2175
2176 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) {
2177 Record.push_back(PPD_INCLUSION_DIRECTIVE);
Douglas Gregor92a96f52011-02-08 21:58:10 +00002178 Record.push_back(ID->getFileName().size());
2179 Record.push_back(ID->wasInQuotes());
2180 Record.push_back(static_cast<unsigned>(ID->getKind()));
Argyrios Kyrtzidisf590e092012-10-02 16:10:46 +00002181 Record.push_back(ID->importedModule());
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00002182 SmallString<64> Buffer;
Douglas Gregor92a96f52011-02-08 21:58:10 +00002183 Buffer += ID->getFileName();
Argyrios Kyrtzidis8dbcfc32012-03-08 01:08:28 +00002184 // Check that the FileEntry is not null because it was not resolved and
2185 // we create a PCH even with compiler errors.
2186 if (ID->getFile())
2187 Buffer += ID->getFile()->getName();
Douglas Gregor92a96f52011-02-08 21:58:10 +00002188 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer);
2189 continue;
2190 }
2191
2192 llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter");
2193 }
Douglas Gregor8f45df52009-04-16 22:23:12 +00002194 Stream.ExitBlock();
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002195
Douglas Gregoraae92242010-03-19 21:51:54 +00002196 // Write the offsets table for the preprocessing record.
2197 if (NumPreprocessingRecords > 0) {
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002198 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2199
Douglas Gregoraae92242010-03-19 21:51:54 +00002200 // Write the offsets table for identifier IDs.
2201 using namespace llvm;
2202 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002203 Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS));
Douglas Gregor2f555fc2011-08-04 18:56:47 +00002204 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity
Douglas Gregoraae92242010-03-19 21:51:54 +00002205 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002206 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002207
Douglas Gregoraae92242010-03-19 21:51:54 +00002208 Record.clear();
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002209 Record.push_back(PPD_ENTITIES_OFFSETS);
Douglas Gregor2f555fc2011-08-04 18:56:47 +00002210 Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS);
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00002211 Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record,
2212 data(PreprocessedEntityOffsets));
Douglas Gregoraae92242010-03-19 21:51:54 +00002213 }
Chris Lattnereeffaef2009-04-10 17:15:23 +00002214}
2215
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002216unsigned ASTWriter::getSubmoduleID(Module *Mod) {
2217 llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod);
2218 if (Known != SubmoduleIDs.end())
2219 return Known->second;
2220
2221 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2222}
2223
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00002224unsigned ASTWriter::getExistingSubmoduleID(Module *Mod) const {
2225 if (!Mod)
2226 return 0;
2227
2228 llvm::DenseMap<Module *, unsigned>::const_iterator
2229 Known = SubmoduleIDs.find(Mod);
2230 if (Known != SubmoduleIDs.end())
2231 return Known->second;
2232
2233 return 0;
2234}
2235
Douglas Gregor253eefe2011-12-01 00:59:36 +00002236/// \brief Compute the number of modules within the given tree (including the
2237/// given module).
2238static unsigned getNumberOfModules(Module *Mod) {
2239 unsigned ChildModules = 0;
Douglas Gregoreb90e832012-01-04 23:32:19 +00002240 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
2241 SubEnd = Mod->submodule_end();
Douglas Gregor253eefe2011-12-01 00:59:36 +00002242 Sub != SubEnd; ++Sub)
Douglas Gregoreb90e832012-01-04 23:32:19 +00002243 ChildModules += getNumberOfModules(*Sub);
Douglas Gregor253eefe2011-12-01 00:59:36 +00002244
2245 return ChildModules + 1;
2246}
2247
Douglas Gregorde3ef502011-11-30 23:21:26 +00002248void ASTWriter::WriteSubmodules(Module *WritingModule) {
Douglas Gregor60382512011-12-05 16:35:23 +00002249 // Determine the dependencies of our module and each of it's submodules.
Douglas Gregor0093b3c2011-12-05 16:33:54 +00002250 // FIXME: This feels like it belongs somewhere else, but there are no
2251 // other consumers of this information.
2252 SourceManager &SrcMgr = PP->getSourceManager();
2253 ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap();
Aaron Ballmanbbc31212014-03-14 20:59:21 +00002254 for (const auto *I : Context->local_imports()) {
Douglas Gregor0093b3c2011-12-05 16:33:54 +00002255 if (Module *ImportedFrom
2256 = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(),
2257 SrcMgr))) {
2258 ImportedFrom->Imports.push_back(I->getImportedModule());
2259 }
2260 }
2261
Douglas Gregor69021972011-11-30 17:33:56 +00002262 // Enter the submodule description block.
2263 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
2264
2265 // Write the abbreviations needed for the submodules block.
2266 using namespace llvm;
2267 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2268 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION));
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002269 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
Douglas Gregor69021972011-11-30 17:33:56 +00002270 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent
2271 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
2272 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit
Richard Smith9bca2982014-03-08 00:03:56 +00002273 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem
2274 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC
Douglas Gregora686e1b2012-01-27 19:52:33 +00002275 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules...
Douglas Gregor73441092011-12-05 22:27:44 +00002276 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit...
Douglas Gregor73441092011-12-05 22:27:44 +00002277 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild...
Douglas Gregor35b13ec2013-03-20 00:22:05 +00002278 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh...
Douglas Gregor69021972011-11-30 17:33:56 +00002279 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2280 unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev);
2281
2282 Abbrev = new BitCodeAbbrev();
Douglas Gregor524e33e2011-12-08 19:11:24 +00002283 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER));
Douglas Gregor69021972011-11-30 17:33:56 +00002284 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2285 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev);
2286
2287 Abbrev = new BitCodeAbbrev();
2288 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER));
2289 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2290 unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev);
Douglas Gregor524e33e2011-12-08 19:11:24 +00002291
2292 Abbrev = new BitCodeAbbrev();
Argyrios Kyrtzidisc597c8c2012-10-05 00:22:33 +00002293 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER));
2294 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2295 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2296
2297 Abbrev = new BitCodeAbbrev();
Douglas Gregor524e33e2011-12-08 19:11:24 +00002298 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR));
2299 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2300 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev);
2301
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00002302 Abbrev = new BitCodeAbbrev();
2303 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES));
Richard Smitha3feee22013-10-28 22:18:19 +00002304 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State
2305 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00002306 unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev);
2307
Douglas Gregor59527662012-10-15 06:28:11 +00002308 Abbrev = new BitCodeAbbrev();
2309 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER));
2310 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2311 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2312
Douglas Gregor6ddfca92013-01-14 17:21:00 +00002313 Abbrev = new BitCodeAbbrev();
Lawrence Crowlb53e5482013-06-20 21:14:14 +00002314 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER));
2315 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2316 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2317
2318 Abbrev = new BitCodeAbbrev();
Douglas Gregor6ddfca92013-01-14 17:21:00 +00002319 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY));
2320 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
2321 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2322 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(Abbrev);
2323
Douglas Gregor35b13ec2013-03-20 00:22:05 +00002324 Abbrev = new BitCodeAbbrev();
2325 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO));
2326 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name
2327 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(Abbrev);
2328
Douglas Gregorfb912652013-03-20 21:10:35 +00002329 Abbrev = new BitCodeAbbrev();
2330 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT));
2331 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module
2332 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message
2333 unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev);
2334
Douglas Gregor253eefe2011-12-01 00:59:36 +00002335 // Write the submodule metadata block.
2336 RecordData Record;
2337 Record.push_back(getNumberOfModules(WritingModule));
2338 Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS);
2339 Stream.EmitRecord(SUBMODULE_METADATA, Record);
2340
Douglas Gregor69021972011-11-30 17:33:56 +00002341 // Write all of the submodules.
Douglas Gregorde3ef502011-11-30 23:21:26 +00002342 std::queue<Module *> Q;
Douglas Gregor69021972011-11-30 17:33:56 +00002343 Q.push(WritingModule);
Douglas Gregor69021972011-11-30 17:33:56 +00002344 while (!Q.empty()) {
Douglas Gregorde3ef502011-11-30 23:21:26 +00002345 Module *Mod = Q.front();
Douglas Gregor69021972011-11-30 17:33:56 +00002346 Q.pop();
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002347 unsigned ID = getSubmoduleID(Mod);
Douglas Gregor69021972011-11-30 17:33:56 +00002348
2349 // Emit the definition of the block.
2350 Record.clear();
2351 Record.push_back(SUBMODULE_DEFINITION);
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002352 Record.push_back(ID);
Douglas Gregor69021972011-11-30 17:33:56 +00002353 if (Mod->Parent) {
2354 assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?");
2355 Record.push_back(SubmoduleIDs[Mod->Parent]);
2356 } else {
2357 Record.push_back(0);
2358 }
2359 Record.push_back(Mod->IsFramework);
2360 Record.push_back(Mod->IsExplicit);
Douglas Gregora686e1b2012-01-27 19:52:33 +00002361 Record.push_back(Mod->IsSystem);
Richard Smith9bca2982014-03-08 00:03:56 +00002362 Record.push_back(Mod->IsExternC);
Douglas Gregor73441092011-12-05 22:27:44 +00002363 Record.push_back(Mod->InferSubmodules);
2364 Record.push_back(Mod->InferExplicitSubmodules);
2365 Record.push_back(Mod->InferExportWildcard);
Douglas Gregor35b13ec2013-03-20 00:22:05 +00002366 Record.push_back(Mod->ConfigMacrosExhaustive);
Douglas Gregor69021972011-11-30 17:33:56 +00002367 Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name);
2368
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00002369 // Emit the requirements.
Richard Smitha3feee22013-10-28 22:18:19 +00002370 for (unsigned I = 0, N = Mod->Requirements.size(); I != N; ++I) {
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00002371 Record.clear();
2372 Record.push_back(SUBMODULE_REQUIRES);
Richard Smitha3feee22013-10-28 22:18:19 +00002373 Record.push_back(Mod->Requirements[I].second);
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00002374 Stream.EmitRecordWithBlob(RequiresAbbrev, Record,
Richard Smitha3feee22013-10-28 22:18:19 +00002375 Mod->Requirements[I].first);
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00002376 }
2377
Douglas Gregor69021972011-11-30 17:33:56 +00002378 // Emit the umbrella header, if there is one.
Douglas Gregor73141fa2011-12-08 17:39:04 +00002379 if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) {
Douglas Gregor69021972011-11-30 17:33:56 +00002380 Record.clear();
Douglas Gregor524e33e2011-12-08 19:11:24 +00002381 Record.push_back(SUBMODULE_UMBRELLA_HEADER);
Douglas Gregor69021972011-11-30 17:33:56 +00002382 Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record,
Douglas Gregor73141fa2011-12-08 17:39:04 +00002383 UmbrellaHeader->getName());
Douglas Gregor524e33e2011-12-08 19:11:24 +00002384 } else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) {
2385 Record.clear();
2386 Record.push_back(SUBMODULE_UMBRELLA_DIR);
2387 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record,
2388 UmbrellaDir->getName());
Douglas Gregor69021972011-11-30 17:33:56 +00002389 }
2390
2391 // Emit the headers.
Lawrence Crowlb53e5482013-06-20 21:14:14 +00002392 for (unsigned I = 0, N = Mod->NormalHeaders.size(); I != N; ++I) {
Douglas Gregor69021972011-11-30 17:33:56 +00002393 Record.clear();
2394 Record.push_back(SUBMODULE_HEADER);
2395 Stream.EmitRecordWithBlob(HeaderAbbrev, Record,
Lawrence Crowlb53e5482013-06-20 21:14:14 +00002396 Mod->NormalHeaders[I]->getName());
Douglas Gregor69021972011-11-30 17:33:56 +00002397 }
Douglas Gregor59527662012-10-15 06:28:11 +00002398 // Emit the excluded headers.
2399 for (unsigned I = 0, N = Mod->ExcludedHeaders.size(); I != N; ++I) {
2400 Record.clear();
2401 Record.push_back(SUBMODULE_EXCLUDED_HEADER);
2402 Stream.EmitRecordWithBlob(ExcludedHeaderAbbrev, Record,
2403 Mod->ExcludedHeaders[I]->getName());
2404 }
Lawrence Crowlb53e5482013-06-20 21:14:14 +00002405 // Emit the private headers.
2406 for (unsigned I = 0, N = Mod->PrivateHeaders.size(); I != N; ++I) {
2407 Record.clear();
2408 Record.push_back(SUBMODULE_PRIVATE_HEADER);
2409 Stream.EmitRecordWithBlob(PrivateHeaderAbbrev, Record,
2410 Mod->PrivateHeaders[I]->getName());
2411 }
Argyrios Kyrtzidis3c5305c2013-03-13 21:13:43 +00002412 ArrayRef<const FileEntry *>
2413 TopHeaders = Mod->getTopHeaders(PP->getFileManager());
2414 for (unsigned I = 0, N = TopHeaders.size(); I != N; ++I) {
Argyrios Kyrtzidisc597c8c2012-10-05 00:22:33 +00002415 Record.clear();
2416 Record.push_back(SUBMODULE_TOPHEADER);
2417 Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record,
Argyrios Kyrtzidis3c5305c2013-03-13 21:13:43 +00002418 TopHeaders[I]->getName());
Argyrios Kyrtzidisc597c8c2012-10-05 00:22:33 +00002419 }
Douglas Gregor0093b3c2011-12-05 16:33:54 +00002420
2421 // Emit the imports.
2422 if (!Mod->Imports.empty()) {
2423 Record.clear();
2424 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) {
Douglas Gregor18b58642011-12-12 23:17:57 +00002425 unsigned ImportedID = getSubmoduleID(Mod->Imports[I]);
Douglas Gregor0093b3c2011-12-05 16:33:54 +00002426 assert(ImportedID && "Unknown submodule!");
2427 Record.push_back(ImportedID);
2428 }
2429 Stream.EmitRecord(SUBMODULE_IMPORTS, Record);
2430 }
2431
Douglas Gregor24bb9232011-12-02 18:58:38 +00002432 // Emit the exports.
2433 if (!Mod->Exports.empty()) {
2434 Record.clear();
2435 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) {
Douglas Gregor18b58642011-12-12 23:17:57 +00002436 if (Module *Exported = Mod->Exports[I].getPointer()) {
2437 unsigned ExportedID = SubmoduleIDs[Exported];
2438 assert(ExportedID > 0 && "Unknown submodule ID?");
2439 Record.push_back(ExportedID);
2440 } else {
2441 Record.push_back(0);
2442 }
2443
Douglas Gregor24bb9232011-12-02 18:58:38 +00002444 Record.push_back(Mod->Exports[I].getInt());
2445 }
2446 Stream.EmitRecord(SUBMODULE_EXPORTS, Record);
2447 }
Douglas Gregor6ddfca92013-01-14 17:21:00 +00002448
Daniel Jasperba7f2f72013-09-24 09:14:14 +00002449 //FIXME: How do we emit the 'use'd modules? They may not be submodules.
2450 // Might be unnecessary as use declarations are only used to build the
2451 // module itself.
2452
Douglas Gregor6ddfca92013-01-14 17:21:00 +00002453 // Emit the link libraries.
2454 for (unsigned I = 0, N = Mod->LinkLibraries.size(); I != N; ++I) {
2455 Record.clear();
2456 Record.push_back(SUBMODULE_LINK_LIBRARY);
2457 Record.push_back(Mod->LinkLibraries[I].IsFramework);
2458 Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record,
2459 Mod->LinkLibraries[I].Library);
2460 }
2461
Douglas Gregorfb912652013-03-20 21:10:35 +00002462 // Emit the conflicts.
2463 for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) {
2464 Record.clear();
2465 Record.push_back(SUBMODULE_CONFLICT);
2466 unsigned OtherID = getSubmoduleID(Mod->Conflicts[I].Other);
2467 assert(OtherID && "Unknown submodule!");
2468 Record.push_back(OtherID);
2469 Stream.EmitRecordWithBlob(ConflictAbbrev, Record,
2470 Mod->Conflicts[I].Message);
2471 }
2472
Douglas Gregor35b13ec2013-03-20 00:22:05 +00002473 // Emit the configuration macros.
2474 for (unsigned I = 0, N = Mod->ConfigMacros.size(); I != N; ++I) {
2475 Record.clear();
2476 Record.push_back(SUBMODULE_CONFIG_MACRO);
2477 Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record,
2478 Mod->ConfigMacros[I]);
2479 }
2480
Douglas Gregor69021972011-11-30 17:33:56 +00002481 // Queue up the submodules of this module.
Douglas Gregoreb90e832012-01-04 23:32:19 +00002482 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
2483 SubEnd = Mod->submodule_end();
Douglas Gregor69021972011-11-30 17:33:56 +00002484 Sub != SubEnd; ++Sub)
Douglas Gregoreb90e832012-01-04 23:32:19 +00002485 Q.push(*Sub);
Douglas Gregor69021972011-11-30 17:33:56 +00002486 }
2487
2488 Stream.ExitBlock();
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002489
2490 assert((NextSubmoduleID - FirstSubmoduleID
2491 == getNumberOfModules(WritingModule)) && "Wrong # of submodules");
Douglas Gregor69021972011-11-30 17:33:56 +00002492}
2493
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002494serialization::SubmoduleID
2495ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) {
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002496 if (Loc.isInvalid() || !WritingModule)
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002497 return 0; // No submodule
Douglas Gregor0093b3c2011-12-05 16:33:54 +00002498
2499 // Find the module that owns this location.
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002500 ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap();
Douglas Gregor0093b3c2011-12-05 16:33:54 +00002501 Module *OwningMod
2502 = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager()));
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002503 if (!OwningMod)
2504 return 0;
2505
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002506 // Check whether this submodule is part of our own module.
2507 if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule))
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002508 return 0;
2509
Douglas Gregora89c5ac2011-12-06 01:10:29 +00002510 return getSubmoduleID(OwningMod);
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002511}
2512
Argyrios Kyrtzidis0f06b982013-03-27 17:17:23 +00002513void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag,
2514 bool isModule) {
2515 // Make sure set diagnostic pragmas don't affect the translation unit that
2516 // imports the module.
2517 // FIXME: Make diagnostic pragma sections work properly with modules.
2518 if (isModule)
2519 return;
2520
Argyrios Kyrtzidisefaa54a2012-10-30 00:27:21 +00002521 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
2522 DiagStateIDMap;
2523 unsigned CurrID = 0;
2524 DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one.
Argyrios Kyrtzidis452707c2010-11-05 22:10:18 +00002525 RecordData Record;
David Blaikie9c902b52011-09-25 23:23:43 +00002526 for (DiagnosticsEngine::DiagStatePointsTy::const_iterator
Argyrios Kyrtzidis243aedb2011-01-14 20:54:07 +00002527 I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end();
2528 I != E; ++I) {
Argyrios Kyrtzidisefaa54a2012-10-30 00:27:21 +00002529 const DiagnosticsEngine::DiagStatePoint &point = *I;
Argyrios Kyrtzidis243aedb2011-01-14 20:54:07 +00002530 if (point.Loc.isInvalid())
2531 continue;
2532
2533 Record.push_back(point.Loc.getRawEncoding());
Argyrios Kyrtzidisefaa54a2012-10-30 00:27:21 +00002534 unsigned &DiagStateID = DiagStateIDMap[point.State];
2535 Record.push_back(DiagStateID);
2536
2537 if (DiagStateID == 0) {
2538 DiagStateID = ++CurrID;
2539 for (DiagnosticsEngine::DiagState::const_iterator
2540 I = point.State->begin(), E = point.State->end(); I != E; ++I) {
2541 if (I->second.isPragma()) {
2542 Record.push_back(I->first);
2543 Record.push_back(I->second.getMapping());
2544 }
Argyrios Kyrtzidis243aedb2011-01-14 20:54:07 +00002545 }
Argyrios Kyrtzidisefaa54a2012-10-30 00:27:21 +00002546 Record.push_back(-1); // mark the end of the diag/map pairs for this
2547 // location.
Argyrios Kyrtzidis452707c2010-11-05 22:10:18 +00002548 }
2549 }
2550
Argyrios Kyrtzidisb0ca9eb2010-11-05 22:20:49 +00002551 if (!Record.empty())
Argyrios Kyrtzidis243aedb2011-01-14 20:54:07 +00002552 Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record);
Argyrios Kyrtzidis452707c2010-11-05 22:10:18 +00002553}
2554
Anders Carlsson9bb83e82011-03-06 18:41:18 +00002555void ASTWriter::WriteCXXBaseSpecifiersOffsets() {
2556 if (CXXBaseSpecifiersOffsets.empty())
2557 return;
2558
2559 RecordData Record;
2560
2561 // Create a blob abbreviation for the C++ base specifiers offsets.
2562 using namespace llvm;
2563
2564 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2565 Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS));
2566 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
2567 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2568 unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2569
Douglas Gregorc27b2872011-08-04 00:01:48 +00002570 // Write the base specifier offsets table.
Anders Carlsson9bb83e82011-03-06 18:41:18 +00002571 Record.clear();
2572 Record.push_back(CXX_BASE_SPECIFIER_OFFSETS);
2573 Record.push_back(CXXBaseSpecifiersOffsets.size());
2574 Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record,
Benjamin Kramerd47a12a2011-04-24 17:44:50 +00002575 data(CXXBaseSpecifiersOffsets));
Anders Carlsson9bb83e82011-03-06 18:41:18 +00002576}
2577
Douglas Gregorc5046832009-04-27 18:38:38 +00002578//===----------------------------------------------------------------------===//
2579// Type Serialization
2580//===----------------------------------------------------------------------===//
Chris Lattnereeffaef2009-04-10 17:15:23 +00002581
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002582/// \brief Write the representation of a type to the AST stream.
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002583void ASTWriter::WriteType(QualType T) {
Argyrios Kyrtzidisa7fbbb02010-08-20 16:04:04 +00002584 TypeIdx &Idx = TypeIdxs[T];
Argyrios Kyrtzidisbb5c7eae2010-08-20 16:03:59 +00002585 if (Idx.getIndex() == 0) // we haven't seen this type before.
2586 Idx = TypeIdx(NextTypeID++);
Mike Stump11289f42009-09-09 15:08:12 +00002587
Douglas Gregor9b3932c2010-10-05 18:37:06 +00002588 assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST");
Douglas Gregordc72caa2010-10-04 18:21:45 +00002589
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002590 // Record the offset for this type.
Argyrios Kyrtzidisbb5c7eae2010-08-20 16:03:59 +00002591 unsigned Index = Idx.getIndex() - FirstTypeID;
Sebastian Redl66c5eef2010-07-27 00:17:23 +00002592 if (TypeOffsets.size() == Index)
Douglas Gregor8f45df52009-04-16 22:23:12 +00002593 TypeOffsets.push_back(Stream.GetCurrentBitNo());
Sebastian Redl66c5eef2010-07-27 00:17:23 +00002594 else if (TypeOffsets.size() < Index) {
2595 TypeOffsets.resize(Index + 1);
2596 TypeOffsets[Index] = Stream.GetCurrentBitNo();
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002597 }
2598
2599 RecordData Record;
Mike Stump11289f42009-09-09 15:08:12 +00002600
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002601 // Emit the type's representation.
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002602 ASTTypeWriter W(*this, Record);
John McCall8ccfcb52009-09-24 19:53:00 +00002603
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00002604 if (T.hasLocalNonFastQualifiers()) {
2605 Qualifiers Qs = T.getLocalQualifiers();
2606 AddTypeRef(T.getLocalUnqualifiedType(), Record);
John McCall8ccfcb52009-09-24 19:53:00 +00002607 Record.push_back(Qs.getAsOpaqueValue());
Sebastian Redl539c5062010-08-18 23:57:32 +00002608 W.Code = TYPE_EXT_QUAL;
John McCall8ccfcb52009-09-24 19:53:00 +00002609 } else {
2610 switch (T->getTypeClass()) {
2611 // For all of the concrete, non-dependent types, call the
2612 // appropriate visitor function.
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002613#define TYPE(Class, Base) \
Mike Stump281d6d72010-01-20 02:03:14 +00002614 case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break;
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002615#define ABSTRACT_TYPE(Class, Base)
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002616#include "clang/AST/TypeNodes.def"
John McCall8ccfcb52009-09-24 19:53:00 +00002617 }
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002618 }
2619
2620 // Emit the serialized record.
Douglas Gregor8f45df52009-04-16 22:23:12 +00002621 Stream.EmitRecord(W.Code, Record);
Douglas Gregorfeb84b02009-04-14 21:18:50 +00002622
2623 // Flush any expressions that were written as part of this type.
Douglas Gregor8f45df52009-04-16 22:23:12 +00002624 FlushStmts();
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002625}
2626
Douglas Gregorc5046832009-04-27 18:38:38 +00002627//===----------------------------------------------------------------------===//
2628// Declaration Serialization
2629//===----------------------------------------------------------------------===//
2630
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002631/// \brief Write the block containing all of the declaration IDs
2632/// lexically declared within the given DeclContext.
2633///
2634/// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
2635/// bistream, or 0 if no block was written.
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002636uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002637 DeclContext *DC) {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002638 if (DC->decls_empty())
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002639 return 0;
2640
Douglas Gregor8f45df52009-04-16 22:23:12 +00002641 uint64_t Offset = Stream.GetCurrentBitNo();
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002642 RecordData Record;
Sebastian Redl539c5062010-08-18 23:57:32 +00002643 Record.push_back(DECL_CONTEXT_LEXICAL);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002644 SmallVector<KindDeclIDPair, 64> Decls;
Aaron Ballman629afae2014-03-07 19:56:05 +00002645 for (const auto *D : DC->decls())
2646 Decls.push_back(std::make_pair(D->getKind(), GetDeclRef(D)));
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002647
Douglas Gregora57c3ab2009-04-22 22:34:57 +00002648 ++NumLexicalDeclContexts;
Benjamin Kramerd47a12a2011-04-24 17:44:50 +00002649 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls));
Douglas Gregoref84c4b2009-04-09 22:27:44 +00002650 return Offset;
2651}
2652
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002653void ASTWriter::WriteTypeDeclOffsets() {
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002654 using namespace llvm;
2655 RecordData Record;
2656
2657 // Write the type offsets array
2658 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00002659 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET));
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002660 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types
Douglas Gregor5204bde2011-08-02 16:26:37 +00002661 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002662 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block
2663 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2664 Record.clear();
Sebastian Redl539c5062010-08-18 23:57:32 +00002665 Record.push_back(TYPE_OFFSET);
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002666 Record.push_back(TypeOffsets.size());
Douglas Gregor5204bde2011-08-02 16:26:37 +00002667 Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS);
Benjamin Kramerd47a12a2011-04-24 17:44:50 +00002668 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets));
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002669
2670 // Write the declaration offsets array
2671 Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00002672 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET));
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002673 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations
Douglas Gregorf7180622011-08-03 15:48:04 +00002674 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002675 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block
2676 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2677 Record.clear();
Sebastian Redl539c5062010-08-18 23:57:32 +00002678 Record.push_back(DECL_OFFSET);
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002679 Record.push_back(DeclOffsets.size());
Douglas Gregor6f8912e2011-08-03 16:05:40 +00002680 Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS);
Benjamin Kramerd47a12a2011-04-24 17:44:50 +00002681 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets));
Sebastian Redl1ea025b2010-07-16 16:36:56 +00002682}
2683
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00002684void ASTWriter::WriteFileDeclIDsMap() {
2685 using namespace llvm;
2686 RecordData Record;
2687
2688 // Join the vectors of DeclIDs from all files.
2689 SmallVector<DeclID, 256> FileSortedIDs;
2690 for (FileDeclIDsTy::iterator
2691 FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) {
2692 DeclIDInFileInfo &Info = *FI->second;
2693 Info.FirstDeclIndex = FileSortedIDs.size();
2694 for (LocDeclIDsTy::iterator
2695 DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI)
2696 FileSortedIDs.push_back(DI->second);
2697 }
2698
2699 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2700 Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS));
Argyrios Kyrtzidis10e78462012-10-02 21:09:13 +00002701 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00002702 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2703 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
2704 Record.push_back(FILE_SORTED_DECLS);
Argyrios Kyrtzidis10e78462012-10-02 21:09:13 +00002705 Record.push_back(FileSortedIDs.size());
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00002706 Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs));
2707}
2708
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00002709void ASTWriter::WriteComments() {
2710 Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3);
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +00002711 ArrayRef<RawComment *> RawComments = Context->Comments.getComments();
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00002712 RecordData Record;
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +00002713 for (ArrayRef<RawComment *>::iterator I = RawComments.begin(),
2714 E = RawComments.end();
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00002715 I != E; ++I) {
2716 Record.clear();
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +00002717 AddSourceRange((*I)->getSourceRange(), Record);
2718 Record.push_back((*I)->getKind());
2719 Record.push_back((*I)->isTrailingComment());
2720 Record.push_back((*I)->isAlmostTrailingComment());
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00002721 Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record);
2722 }
2723 Stream.ExitBlock();
2724}
2725
Douglas Gregorc5046832009-04-27 18:38:38 +00002726//===----------------------------------------------------------------------===//
2727// Global Method Pool and Selector Serialization
2728//===----------------------------------------------------------------------===//
2729
Douglas Gregore84a9da2009-04-20 20:36:09 +00002730namespace {
Douglas Gregorc78d3462009-04-24 21:10:55 +00002731// Trait used for the on-disk hash table used in the method pool.
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002732class ASTMethodPoolTrait {
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002733 ASTWriter &Writer;
Douglas Gregorc78d3462009-04-24 21:10:55 +00002734
2735public:
2736 typedef Selector key_type;
2737 typedef key_type key_type_ref;
Mike Stump11289f42009-09-09 15:08:12 +00002738
Sebastian Redl834bb972010-08-04 17:20:04 +00002739 struct data_type {
Sebastian Redl539c5062010-08-18 23:57:32 +00002740 SelectorID ID;
Sebastian Redl834bb972010-08-04 17:20:04 +00002741 ObjCMethodList Instance, Factory;
2742 };
Douglas Gregorc78d3462009-04-24 21:10:55 +00002743 typedef const data_type& data_type_ref;
2744
Justin Bogner25463f12014-04-18 20:27:24 +00002745 typedef unsigned hash_value_type;
2746 typedef unsigned offset_type;
2747
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002748 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { }
Mike Stump11289f42009-09-09 15:08:12 +00002749
Justin Bogner25463f12014-04-18 20:27:24 +00002750 static hash_value_type ComputeHash(Selector Sel) {
Argyrios Kyrtzidis4bd97102010-08-20 16:03:52 +00002751 return serialization::ComputeHash(Sel);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002752 }
Mike Stump11289f42009-09-09 15:08:12 +00002753
2754 std::pair<unsigned,unsigned>
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002755 EmitKeyDataLength(raw_ostream& Out, Selector Sel,
Douglas Gregorc78d3462009-04-24 21:10:55 +00002756 data_type_ref Methods) {
Justin Bognere1c147c2014-03-28 22:03:19 +00002757 using namespace llvm::support;
2758 endian::Writer<little> LE(Out);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002759 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
Justin Bognere1c147c2014-03-28 22:03:19 +00002760 LE.write<uint16_t>(KeyLen);
Sebastian Redl834bb972010-08-04 17:20:04 +00002761 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
2762 for (const ObjCMethodList *Method = &Methods.Instance; Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002763 Method = Method->getNext())
Douglas Gregorc78d3462009-04-24 21:10:55 +00002764 if (Method->Method)
2765 DataLen += 4;
Sebastian Redl834bb972010-08-04 17:20:04 +00002766 for (const ObjCMethodList *Method = &Methods.Factory; Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002767 Method = Method->getNext())
Douglas Gregorc78d3462009-04-24 21:10:55 +00002768 if (Method->Method)
2769 DataLen += 4;
Justin Bognere1c147c2014-03-28 22:03:19 +00002770 LE.write<uint16_t>(DataLen);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002771 return std::make_pair(KeyLen, DataLen);
2772 }
Mike Stump11289f42009-09-09 15:08:12 +00002773
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002774 void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
Justin Bognere1c147c2014-03-28 22:03:19 +00002775 using namespace llvm::support;
2776 endian::Writer<little> LE(Out);
Mike Stump11289f42009-09-09 15:08:12 +00002777 uint64_t Start = Out.tell();
Douglas Gregor95c13f52009-04-25 17:48:32 +00002778 assert((Start >> 32) == 0 && "Selector key offset too large");
2779 Writer.SetSelectorOffset(Sel, Start);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002780 unsigned N = Sel.getNumArgs();
Justin Bognere1c147c2014-03-28 22:03:19 +00002781 LE.write<uint16_t>(N);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002782 if (N == 0)
2783 N = 1;
2784 for (unsigned I = 0; I != N; ++I)
Justin Bognere1c147c2014-03-28 22:03:19 +00002785 LE.write<uint32_t>(
2786 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
Douglas Gregorc78d3462009-04-24 21:10:55 +00002787 }
Mike Stump11289f42009-09-09 15:08:12 +00002788
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002789 void EmitData(raw_ostream& Out, key_type_ref,
Douglas Gregor4647cfa2009-04-24 21:49:02 +00002790 data_type_ref Methods, unsigned DataLen) {
Justin Bognere1c147c2014-03-28 22:03:19 +00002791 using namespace llvm::support;
2792 endian::Writer<little> LE(Out);
Douglas Gregor4647cfa2009-04-24 21:49:02 +00002793 uint64_t Start = Out.tell(); (void)Start;
Justin Bognere1c147c2014-03-28 22:03:19 +00002794 LE.write<uint32_t>(Methods.ID);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002795 unsigned NumInstanceMethods = 0;
Sebastian Redl834bb972010-08-04 17:20:04 +00002796 for (const ObjCMethodList *Method = &Methods.Instance; Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002797 Method = Method->getNext())
Douglas Gregorc78d3462009-04-24 21:10:55 +00002798 if (Method->Method)
2799 ++NumInstanceMethods;
2800
2801 unsigned NumFactoryMethods = 0;
Sebastian Redl834bb972010-08-04 17:20:04 +00002802 for (const ObjCMethodList *Method = &Methods.Factory; Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002803 Method = Method->getNext())
Douglas Gregorc78d3462009-04-24 21:10:55 +00002804 if (Method->Method)
2805 ++NumFactoryMethods;
2806
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002807 unsigned InstanceBits = Methods.Instance.getBits();
2808 assert(InstanceBits < 4);
2809 unsigned NumInstanceMethodsAndBits =
2810 (NumInstanceMethods << 2) | InstanceBits;
2811 unsigned FactoryBits = Methods.Factory.getBits();
2812 assert(FactoryBits < 4);
2813 unsigned NumFactoryMethodsAndBits = (NumFactoryMethods << 2) | FactoryBits;
Justin Bognere1c147c2014-03-28 22:03:19 +00002814 LE.write<uint16_t>(NumInstanceMethodsAndBits);
2815 LE.write<uint16_t>(NumFactoryMethodsAndBits);
Sebastian Redl834bb972010-08-04 17:20:04 +00002816 for (const ObjCMethodList *Method = &Methods.Instance; Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002817 Method = Method->getNext())
Douglas Gregorc78d3462009-04-24 21:10:55 +00002818 if (Method->Method)
Justin Bognere1c147c2014-03-28 22:03:19 +00002819 LE.write<uint32_t>(Writer.getDeclID(Method->Method));
Sebastian Redl834bb972010-08-04 17:20:04 +00002820 for (const ObjCMethodList *Method = &Methods.Factory; Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002821 Method = Method->getNext())
Douglas Gregorc78d3462009-04-24 21:10:55 +00002822 if (Method->Method)
Justin Bognere1c147c2014-03-28 22:03:19 +00002823 LE.write<uint32_t>(Writer.getDeclID(Method->Method));
Douglas Gregor4647cfa2009-04-24 21:49:02 +00002824
2825 assert(Out.tell() - Start == DataLen && "Data length is wrong");
Douglas Gregorc78d3462009-04-24 21:10:55 +00002826 }
2827};
2828} // end anonymous namespace
2829
Sebastian Redla19a67f2010-08-03 21:58:15 +00002830/// \brief Write ObjC data: selectors and the method pool.
Douglas Gregorc78d3462009-04-24 21:10:55 +00002831///
2832/// The method pool contains both instance and factory methods, stored
Sebastian Redla19a67f2010-08-03 21:58:15 +00002833/// in an on-disk hash table indexed by the selector. The hash table also
2834/// contains an empty entry for every other selector known to Sema.
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002835void ASTWriter::WriteSelectors(Sema &SemaRef) {
Douglas Gregorc78d3462009-04-24 21:10:55 +00002836 using namespace llvm;
2837
Sebastian Redla19a67f2010-08-03 21:58:15 +00002838 // Do we have to do anything at all?
Sebastian Redl834bb972010-08-04 17:20:04 +00002839 if (SemaRef.MethodPool.empty() && SelectorIDs.empty())
Sebastian Redla19a67f2010-08-03 21:58:15 +00002840 return;
Sebastian Redld95a56e2010-08-04 18:21:41 +00002841 unsigned NumTableEntries = 0;
Sebastian Redla19a67f2010-08-03 21:58:15 +00002842 // Create and write out the blob that contains selectors and the method pool.
Douglas Gregorc78d3462009-04-24 21:10:55 +00002843 {
Justin Bognerbb094f02014-04-18 19:57:06 +00002844 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00002845 ASTMethodPoolTrait Trait(*this);
Mike Stump11289f42009-09-09 15:08:12 +00002846
Sebastian Redla19a67f2010-08-03 21:58:15 +00002847 // Create the on-disk hash table representation. We walk through every
2848 // selector we've seen and look it up in the method pool.
Sebastian Redld95a56e2010-08-04 18:21:41 +00002849 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
Sebastian Redl539c5062010-08-18 23:57:32 +00002850 for (llvm::DenseMap<Selector, SelectorID>::iterator
Sebastian Redl834bb972010-08-04 17:20:04 +00002851 I = SelectorIDs.begin(), E = SelectorIDs.end();
2852 I != E; ++I) {
2853 Selector S = I->first;
Sebastian Redla19a67f2010-08-03 21:58:15 +00002854 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S);
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002855 ASTMethodPoolTrait::data_type Data = {
Sebastian Redl834bb972010-08-04 17:20:04 +00002856 I->second,
2857 ObjCMethodList(),
2858 ObjCMethodList()
2859 };
2860 if (F != SemaRef.MethodPool.end()) {
2861 Data.Instance = F->second.first;
2862 Data.Factory = F->second.second;
2863 }
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002864 // Only write this selector if it's not in an existing AST or something
Sebastian Redld95a56e2010-08-04 18:21:41 +00002865 // changed.
2866 if (Chain && I->second < FirstSelectorID) {
2867 // Selector already exists. Did it change?
2868 bool changed = false;
2869 for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002870 M = M->getNext()) {
Douglas Gregorb3722e22011-09-09 23:01:35 +00002871 if (!M->Method->isFromASTFile())
Sebastian Redld95a56e2010-08-04 18:21:41 +00002872 changed = true;
2873 }
2874 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00002875 M = M->getNext()) {
Douglas Gregorb3722e22011-09-09 23:01:35 +00002876 if (!M->Method->isFromASTFile())
Sebastian Redld95a56e2010-08-04 18:21:41 +00002877 changed = true;
2878 }
2879 if (!changed)
2880 continue;
Sebastian Redl6e1a2a02010-08-04 21:22:45 +00002881 } else if (Data.Instance.Method || Data.Factory.Method) {
2882 // A new method pool entry.
2883 ++NumTableEntries;
Sebastian Redld95a56e2010-08-04 18:21:41 +00002884 }
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00002885 Generator.insert(S, Data, Trait);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002886 }
2887
Douglas Gregorc78d3462009-04-24 21:10:55 +00002888 // Create the on-disk hash table in a buffer.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00002889 SmallString<4096> MethodPool;
Douglas Gregorc78d3462009-04-24 21:10:55 +00002890 uint32_t BucketOffset;
2891 {
Justin Bognere1c147c2014-03-28 22:03:19 +00002892 using namespace llvm::support;
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002893 ASTMethodPoolTrait Trait(*this);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002894 llvm::raw_svector_ostream Out(MethodPool);
2895 // Make sure that no bucket is at offset 0
Justin Bognere1c147c2014-03-28 22:03:19 +00002896 endian::Writer<little>(Out).write<uint32_t>(0);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002897 BucketOffset = Generator.Emit(Out, Trait);
2898 }
2899
2900 // Create a blob abbreviation
2901 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00002902 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
Douglas Gregorc78d3462009-04-24 21:10:55 +00002903 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Douglas Gregor95c13f52009-04-25 17:48:32 +00002904 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Douglas Gregorc78d3462009-04-24 21:10:55 +00002905 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2906 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev);
2907
Douglas Gregor95c13f52009-04-25 17:48:32 +00002908 // Write the method pool
Douglas Gregorc78d3462009-04-24 21:10:55 +00002909 RecordData Record;
Sebastian Redl539c5062010-08-18 23:57:32 +00002910 Record.push_back(METHOD_POOL);
Douglas Gregorc78d3462009-04-24 21:10:55 +00002911 Record.push_back(BucketOffset);
Sebastian Redld95a56e2010-08-04 18:21:41 +00002912 Record.push_back(NumTableEntries);
Daniel Dunbar8100d012009-08-24 09:31:37 +00002913 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str());
Douglas Gregor95c13f52009-04-25 17:48:32 +00002914
2915 // Create a blob abbreviation for the selector table offsets.
2916 Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00002917 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
Douglas Gregord4c5ed02010-10-29 22:39:52 +00002918 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
Douglas Gregor8f364fb2011-08-03 23:28:44 +00002919 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
Douglas Gregor95c13f52009-04-25 17:48:32 +00002920 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2921 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2922
2923 // Write the selector offsets table.
2924 Record.clear();
Sebastian Redl539c5062010-08-18 23:57:32 +00002925 Record.push_back(SELECTOR_OFFSETS);
Douglas Gregor95c13f52009-04-25 17:48:32 +00002926 Record.push_back(SelectorOffsets.size());
Douglas Gregor8f364fb2011-08-03 23:28:44 +00002927 Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS);
Douglas Gregor95c13f52009-04-25 17:48:32 +00002928 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
Benjamin Kramerd47a12a2011-04-24 17:44:50 +00002929 data(SelectorOffsets));
Douglas Gregorc78d3462009-04-24 21:10:55 +00002930 }
2931}
2932
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002933/// \brief Write the selectors referenced in @selector expression into AST file.
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002934void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
Fariborz Jahanianc51609a2010-07-23 19:11:11 +00002935 using namespace llvm;
2936 if (SemaRef.ReferencedSelectors.empty())
2937 return;
Sebastian Redlada023c2010-08-04 20:40:17 +00002938
Fariborz Jahanianc51609a2010-07-23 19:11:11 +00002939 RecordData Record;
Sebastian Redlada023c2010-08-04 20:40:17 +00002940
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002941 // Note: this writes out all references even for a dependent AST. But it is
Sebastian Redl51c79d82010-08-04 22:21:29 +00002942 // very tricky to fix, and given that @selector shouldn't really appear in
2943 // headers, probably not worth it. It's not a correctness issue.
Fariborz Jahanianc51609a2010-07-23 19:11:11 +00002944 for (DenseMap<Selector, SourceLocation>::iterator S =
2945 SemaRef.ReferencedSelectors.begin(),
2946 E = SemaRef.ReferencedSelectors.end(); S != E; ++S) {
2947 Selector Sel = (*S).first;
2948 SourceLocation Loc = (*S).second;
2949 AddSelectorRef(Sel, Record);
2950 AddSourceLocation(Loc, Record);
2951 }
Sebastian Redl539c5062010-08-18 23:57:32 +00002952 Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record);
Fariborz Jahanianc51609a2010-07-23 19:11:11 +00002953}
2954
Douglas Gregorc5046832009-04-27 18:38:38 +00002955//===----------------------------------------------------------------------===//
2956// Identifier Table Serialization
2957//===----------------------------------------------------------------------===//
2958
Douglas Gregorc78d3462009-04-24 21:10:55 +00002959namespace {
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002960class ASTIdentifierTableTrait {
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002961 ASTWriter &Writer;
Douglas Gregorc3366a52009-04-21 23:56:24 +00002962 Preprocessor &PP;
Douglas Gregor935bc7a22011-10-27 09:33:13 +00002963 IdentifierResolver &IdResolver;
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00002964 bool IsModule;
2965
Douglas Gregor1d583f22009-04-28 21:18:29 +00002966 /// \brief Determines whether this is an "interesting" identifier
2967 /// that needs a full IdentifierInfo structure written into the hash
2968 /// table.
Argyrios Kyrtzidis09c9e812013-02-20 00:54:57 +00002969 bool isInterestingIdentifier(IdentifierInfo *II, MacroDirective *&Macro) {
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00002970 if (II->isPoisoned() ||
2971 II->isExtensionToken() ||
2972 II->getObjCOrBuiltinID() ||
Douglas Gregor935bc7a22011-10-27 09:33:13 +00002973 II->hasRevertedTokenIDToIdentifier() ||
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00002974 II->getFETokenInfo<void>())
2975 return true;
2976
Alexander Kornienko1d26c022012-09-25 17:18:14 +00002977 return hadMacroDefinition(II, Macro);
Douglas Gregord7910e92011-09-14 22:14:14 +00002978 }
Alexander Kornienko1d26c022012-09-25 17:18:14 +00002979
Argyrios Kyrtzidis09c9e812013-02-20 00:54:57 +00002980 bool hadMacroDefinition(IdentifierInfo *II, MacroDirective *&Macro) {
Alexander Kornienko1d26c022012-09-25 17:18:14 +00002981 if (!II->hadMacroDefinition())
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00002982 return false;
Alexander Kornienko1d26c022012-09-25 17:18:14 +00002983
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00002984 if (Macro || (Macro = PP.getMacroDirectiveHistory(II))) {
2985 if (!IsModule)
2986 return !shouldIgnoreMacro(Macro, IsModule, PP);
2987 SubmoduleID ModID;
2988 if (getFirstPublicSubmoduleMacro(Macro, ModID))
2989 return true;
2990 }
Alexander Kornienko1d26c022012-09-25 17:18:14 +00002991
2992 return false;
Douglas Gregor1d583f22009-04-28 21:18:29 +00002993 }
2994
Richard Smith49f906a2014-03-01 00:08:04 +00002995 typedef llvm::SmallVectorImpl<SubmoduleID> OverriddenList;
2996
2997 MacroDirective *
2998 getFirstPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID) {
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00002999 ModID = 0;
Richard Smith49f906a2014-03-01 00:08:04 +00003000 llvm::SmallVector<SubmoduleID, 1> Overridden;
3001 if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD, ModID, Overridden))
3002 if (!shouldIgnoreMacro(NextMD, IsModule, PP))
3003 return NextMD;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003004 return 0;
3005 }
3006
Richard Smith49f906a2014-03-01 00:08:04 +00003007 MacroDirective *
3008 getNextPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID,
3009 OverriddenList &Overridden) {
3010 if (MacroDirective *NextMD =
3011 getPublicSubmoduleMacro(MD->getPrevious(), ModID, Overridden))
3012 if (!shouldIgnoreMacro(NextMD, IsModule, PP))
3013 return NextMD;
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003014 return 0;
3015 }
3016
3017 /// \brief Traverses the macro directives history and returns the latest
Richard Smith49f906a2014-03-01 00:08:04 +00003018 /// public macro definition or undefinition that is not in ModID.
3019 /// A macro that is defined in submodule A and undefined in submodule B
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003020 /// will still be considered as defined/exported from submodule A.
Richard Smith49f906a2014-03-01 00:08:04 +00003021 /// ModID is updated to the module containing the returned directive.
3022 ///
3023 /// FIXME: This process breaks down if a module defines a macro, imports
3024 /// another submodule that changes the macro, then changes the
3025 /// macro again itself.
3026 MacroDirective *getPublicSubmoduleMacro(MacroDirective *MD,
3027 SubmoduleID &ModID,
3028 OverriddenList &Overridden) {
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003029 if (!MD)
3030 return 0;
3031
Richard Smith49f906a2014-03-01 00:08:04 +00003032 Overridden.clear();
Argyrios Kyrtzidis3e612b42013-04-03 05:11:33 +00003033 SubmoduleID OrigModID = ModID;
Richard Smith49f906a2014-03-01 00:08:04 +00003034 Optional<bool> IsPublic;
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003035 for (; MD; MD = MD->getPrevious()) {
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003036 SubmoduleID ThisModID = getSubmoduleID(MD);
3037 if (ThisModID == 0) {
Richard Smith49f906a2014-03-01 00:08:04 +00003038 IsPublic = Optional<bool>();
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003039 continue;
3040 }
Richard Smith49f906a2014-03-01 00:08:04 +00003041 if (ThisModID != ModID) {
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003042 ModID = ThisModID;
Richard Smith49f906a2014-03-01 00:08:04 +00003043 IsPublic = Optional<bool>();
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003044 }
Richard Smith49f906a2014-03-01 00:08:04 +00003045
3046 // If this is a definition from a submodule import, that submodule's
3047 // definition is overridden by the definition or undefinition that we
3048 // started with.
3049 // FIXME: This should only apply to macros defined in OrigModID.
3050 // We can't do that currently, because a #include of a different submodule
3051 // of the same module just leaks through macros instead of providing new
3052 // DefMacroDirectives for them.
Richard Smith9d100862014-03-06 03:16:27 +00003053 if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) {
3054 // Figure out which submodule the macro was originally defined within.
3055 SubmoduleID SourceID = DefMD->getInfo()->getOwningModuleID();
3056 if (!SourceID) {
3057 SourceLocation DefLoc = DefMD->getInfo()->getDefinitionLoc();
3058 if (DefLoc == MD->getLocation())
3059 SourceID = ThisModID;
3060 else
3061 SourceID = Writer.inferSubmoduleIDFromLocation(DefLoc);
3062 }
3063 if (SourceID != OrigModID)
Richard Smith49f906a2014-03-01 00:08:04 +00003064 Overridden.push_back(SourceID);
Richard Smith9d100862014-03-06 03:16:27 +00003065 }
Richard Smith49f906a2014-03-01 00:08:04 +00003066
Argyrios Kyrtzidis3e612b42013-04-03 05:11:33 +00003067 // We are looking for a definition in a different submodule than the one
3068 // that we started with. If a submodule has re-definitions of the same
3069 // macro, only the last definition will be used as the "exported" one.
3070 if (ModID == OrigModID)
3071 continue;
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003072
Richard Smith49f906a2014-03-01 00:08:04 +00003073 // The latest visibility directive for a name in a submodule affects all
3074 // the directives that come before it.
3075 if (VisibilityMacroDirective *VisMD =
3076 dyn_cast<VisibilityMacroDirective>(MD)) {
3077 if (!IsPublic.hasValue())
3078 IsPublic = VisMD->isPublic();
3079 } else if (!IsPublic.hasValue() || IsPublic.getValue()) {
3080 // FIXME: If we find an imported macro, we should include its list of
3081 // overrides in our export.
3082 return MD;
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003083 }
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003084 }
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003085
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003086 return 0;
3087 }
3088
3089 SubmoduleID getSubmoduleID(MacroDirective *MD) {
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00003090 return Writer.inferSubmoduleIDFromLocation(MD->getLocation());
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003091 }
3092
Douglas Gregore84a9da2009-04-20 20:36:09 +00003093public:
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00003094 typedef IdentifierInfo* key_type;
Douglas Gregore84a9da2009-04-20 20:36:09 +00003095 typedef key_type key_type_ref;
Mike Stump11289f42009-09-09 15:08:12 +00003096
Sebastian Redl539c5062010-08-18 23:57:32 +00003097 typedef IdentID data_type;
Douglas Gregore84a9da2009-04-20 20:36:09 +00003098 typedef data_type data_type_ref;
Mike Stump11289f42009-09-09 15:08:12 +00003099
Justin Bogner25463f12014-04-18 20:27:24 +00003100 typedef unsigned hash_value_type;
3101 typedef unsigned offset_type;
3102
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003103 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP,
3104 IdentifierResolver &IdResolver, bool IsModule)
3105 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { }
Douglas Gregore84a9da2009-04-20 20:36:09 +00003106
Justin Bogner25463f12014-04-18 20:27:24 +00003107 static hash_value_type ComputeHash(const IdentifierInfo* II) {
Daniel Dunbarf8502d52009-10-17 23:52:28 +00003108 return llvm::HashString(II->getName());
Douglas Gregore84a9da2009-04-20 20:36:09 +00003109 }
Mike Stump11289f42009-09-09 15:08:12 +00003110
3111 std::pair<unsigned,unsigned>
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003112 EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) {
Daniel Dunbar2c422dc92009-10-18 20:26:12 +00003113 unsigned KeyLen = II->getLength() + 1;
Douglas Gregor1d583f22009-04-28 21:18:29 +00003114 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1
Argyrios Kyrtzidis09c9e812013-02-20 00:54:57 +00003115 MacroDirective *Macro = 0;
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00003116 if (isInterestingIdentifier(II, Macro)) {
Alexander Kornienko1d26c022012-09-25 17:18:14 +00003117 DataLen += 2; // 2 bytes for builtin ID
3118 DataLen += 2; // 2 bytes for flags
Argyrios Kyrtzidis719736c2013-01-19 03:14:56 +00003119 if (hadMacroDefinition(II, Macro)) {
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003120 DataLen += 4; // MacroDirectives offset.
3121 if (IsModule) {
3122 SubmoduleID ModID;
Richard Smith49f906a2014-03-01 00:08:04 +00003123 llvm::SmallVector<SubmoduleID, 4> Overridden;
3124 for (MacroDirective *
3125 MD = getFirstPublicSubmoduleMacro(Macro, ModID);
3126 MD; MD = getNextPublicSubmoduleMacro(MD, ModID, Overridden)) {
3127 // Previous macro's overrides.
3128 if (!Overridden.empty())
3129 DataLen += 4 * (1 + Overridden.size());
3130 DataLen += 4; // MacroInfo ID or ModuleID.
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003131 }
Richard Smith49f906a2014-03-01 00:08:04 +00003132 // Previous macro's overrides.
3133 if (!Overridden.empty())
3134 DataLen += 4 * (1 + Overridden.size());
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003135 DataLen += 4;
Argyrios Kyrtzidis719736c2013-01-19 03:14:56 +00003136 }
Argyrios Kyrtzidis719736c2013-01-19 03:14:56 +00003137 }
Alexander Kornienko1d26c022012-09-25 17:18:14 +00003138
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003139 for (IdentifierResolver::iterator D = IdResolver.begin(II),
3140 DEnd = IdResolver.end();
Douglas Gregor1d583f22009-04-28 21:18:29 +00003141 D != DEnd; ++D)
Sebastian Redl539c5062010-08-18 23:57:32 +00003142 DataLen += sizeof(DeclID);
Douglas Gregor1d583f22009-04-28 21:18:29 +00003143 }
Justin Bognere1c147c2014-03-28 22:03:19 +00003144 using namespace llvm::support;
3145 endian::Writer<little> LE(Out);
3146
3147 LE.write<uint16_t>(DataLen);
Douglas Gregorab4df582009-04-28 20:01:51 +00003148 // We emit the key length after the data length so that every
3149 // string is preceded by a 16-bit length. This matches the PTH
3150 // format for storing identifiers.
Justin Bognere1c147c2014-03-28 22:03:19 +00003151 LE.write<uint16_t>(KeyLen);
Douglas Gregore84a9da2009-04-20 20:36:09 +00003152 return std::make_pair(KeyLen, DataLen);
3153 }
Mike Stump11289f42009-09-09 15:08:12 +00003154
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003155 void EmitKey(raw_ostream& Out, const IdentifierInfo* II,
Douglas Gregore84a9da2009-04-20 20:36:09 +00003156 unsigned KeyLen) {
3157 // Record the location of the key data. This is used when generating
3158 // the mapping from persistent IDs to strings.
3159 Writer.SetIdentifierOffset(II, Out.tell());
Daniel Dunbar2c422dc92009-10-18 20:26:12 +00003160 Out.write(II->getNameStart(), KeyLen);
Douglas Gregore84a9da2009-04-20 20:36:09 +00003161 }
Mike Stump11289f42009-09-09 15:08:12 +00003162
Richard Smith49f906a2014-03-01 00:08:04 +00003163 static void emitMacroOverrides(raw_ostream &Out,
3164 llvm::ArrayRef<SubmoduleID> Overridden) {
3165 if (!Overridden.empty()) {
Justin Bognere1c147c2014-03-28 22:03:19 +00003166 using namespace llvm::support;
3167 endian::Writer<little> LE(Out);
3168 LE.write<uint32_t>(Overridden.size() | 0x80000000U);
Richard Smith49f906a2014-03-01 00:08:04 +00003169 for (unsigned I = 0, N = Overridden.size(); I != N; ++I)
Justin Bognere1c147c2014-03-28 22:03:19 +00003170 LE.write<uint32_t>(Overridden[I]);
Richard Smith49f906a2014-03-01 00:08:04 +00003171 }
3172 }
3173
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00003174 void EmitData(raw_ostream& Out, IdentifierInfo* II,
Sebastian Redl539c5062010-08-18 23:57:32 +00003175 IdentID ID, unsigned) {
Justin Bognere1c147c2014-03-28 22:03:19 +00003176 using namespace llvm::support;
3177 endian::Writer<little> LE(Out);
Argyrios Kyrtzidis09c9e812013-02-20 00:54:57 +00003178 MacroDirective *Macro = 0;
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00003179 if (!isInterestingIdentifier(II, Macro)) {
Justin Bognere1c147c2014-03-28 22:03:19 +00003180 LE.write<uint32_t>(ID << 1);
Douglas Gregor1d583f22009-04-28 21:18:29 +00003181 return;
3182 }
Douglas Gregorb9256522009-04-28 21:32:13 +00003183
Justin Bognere1c147c2014-03-28 22:03:19 +00003184 LE.write<uint32_t>((ID << 1) | 0x01);
Alexander Kornienko1d26c022012-09-25 17:18:14 +00003185 uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID();
3186 assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader.");
Justin Bognere1c147c2014-03-28 22:03:19 +00003187 LE.write<uint16_t>(Bits);
Alexander Kornienko1d26c022012-09-25 17:18:14 +00003188 Bits = 0;
3189 bool HadMacroDefinition = hadMacroDefinition(II, Macro);
Alexander Kornienko1d26c022012-09-25 17:18:14 +00003190 Bits = (Bits << 1) | unsigned(HadMacroDefinition);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003191 Bits = (Bits << 1) | unsigned(IsModule);
Daniel Dunbar91b640a2009-12-18 20:58:47 +00003192 Bits = (Bits << 1) | unsigned(II->isExtensionToken());
3193 Bits = (Bits << 1) | unsigned(II->isPoisoned());
Argyrios Kyrtzidis3084a612010-08-11 22:55:12 +00003194 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
Daniel Dunbar91b640a2009-12-18 20:58:47 +00003195 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
Justin Bognere1c147c2014-03-28 22:03:19 +00003196 LE.write<uint16_t>(Bits);
Douglas Gregore84a9da2009-04-20 20:36:09 +00003197
Alexander Kornienko1d26c022012-09-25 17:18:14 +00003198 if (HadMacroDefinition) {
Justin Bognere1c147c2014-03-28 22:03:19 +00003199 LE.write<uint32_t>(Writer.getMacroDirectivesOffset(II));
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003200 if (IsModule) {
3201 // Write the IDs of macros coming from different submodules.
3202 SubmoduleID ModID;
Richard Smith49f906a2014-03-01 00:08:04 +00003203 llvm::SmallVector<SubmoduleID, 4> Overridden;
3204 for (MacroDirective *
3205 MD = getFirstPublicSubmoduleMacro(Macro, ModID);
3206 MD; MD = getNextPublicSubmoduleMacro(MD, ModID, Overridden)) {
3207 MacroID InfoID = 0;
3208 emitMacroOverrides(Out, Overridden);
3209 if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) {
3210 InfoID = Writer.getMacroID(DefMD->getInfo());
3211 assert(InfoID);
Justin Bognere1c147c2014-03-28 22:03:19 +00003212 LE.write<uint32_t>(InfoID << 1);
Richard Smith49f906a2014-03-01 00:08:04 +00003213 } else {
3214 assert(isa<UndefMacroDirective>(MD));
Justin Bognere1c147c2014-03-28 22:03:19 +00003215 LE.write<uint32_t>((ModID << 1) | 1);
Richard Smith49f906a2014-03-01 00:08:04 +00003216 }
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00003217 }
Richard Smith49f906a2014-03-01 00:08:04 +00003218 emitMacroOverrides(Out, Overridden);
Justin Bognere1c147c2014-03-28 22:03:19 +00003219 LE.write<uint32_t>(0);
Argyrios Kyrtzidis719736c2013-01-19 03:14:56 +00003220 }
Douglas Gregor7b8e4bc2011-12-02 15:45:10 +00003221 }
Alexander Kornienko1d26c022012-09-25 17:18:14 +00003222
Douglas Gregora868bbd2009-04-21 22:25:48 +00003223 // Emit the declaration IDs in reverse order, because the
3224 // IdentifierResolver provides the declarations as they would be
3225 // visible (e.g., the function "stat" would come before the struct
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003226 // "stat"), but the ASTReader adds declarations to the end of the list
3227 // (so we need to see the struct "status" before the function "status").
Sebastian Redlff4a2952010-07-23 23:49:55 +00003228 // Only emit declarations that aren't from a chained PCH, though.
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003229 SmallVector<Decl *, 16> Decls(IdResolver.begin(II),
3230 IdResolver.end());
Craig Topper2341c0d2013-07-04 03:08:24 +00003231 for (SmallVectorImpl<Decl *>::reverse_iterator D = Decls.rbegin(),
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003232 DEnd = Decls.rend();
Douglas Gregore84a9da2009-04-20 20:36:09 +00003233 D != DEnd; ++D)
Justin Bognere1c147c2014-03-28 22:03:19 +00003234 LE.write<uint32_t>(Writer.getDeclID(getMostRecentLocalDecl(*D)));
Argyrios Kyrtzidise5edbf92013-04-26 21:33:35 +00003235 }
3236
3237 /// \brief Returns the most recent local decl or the given decl if there are
3238 /// no local ones. The given decl is assumed to be the most recent one.
3239 Decl *getMostRecentLocalDecl(Decl *Orig) {
3240 // The only way a "from AST file" decl would be more recent from a local one
3241 // is if it came from a module.
3242 if (!PP.getLangOpts().Modules)
3243 return Orig;
3244
3245 // Look for a local in the decl chain.
3246 for (Decl *D = Orig; D; D = D->getPreviousDecl()) {
3247 if (!D->isFromASTFile())
3248 return D;
3249 // If we come up a decl from a (chained-)PCH stop since we won't find a
3250 // local one.
3251 if (D->getOwningModuleID() == 0)
3252 break;
3253 }
3254
3255 return Orig;
Douglas Gregore84a9da2009-04-20 20:36:09 +00003256 }
3257};
3258} // end anonymous namespace
3259
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00003260/// \brief Write the identifier table into the AST file.
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003261///
3262/// The identifier table consists of a blob containing string data
3263/// (the actual identifiers themselves) and a separate "offsets" index
3264/// that maps identifier IDs to locations within the blob.
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003265void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
3266 IdentifierResolver &IdResolver,
3267 bool IsModule) {
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003268 using namespace llvm;
3269
3270 // Create and write out the blob that contains the identifier
3271 // strings.
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003272 {
Justin Bognerbb094f02014-04-18 19:57:06 +00003273 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003274 ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
Mike Stump11289f42009-09-09 15:08:12 +00003275
Douglas Gregore6648fb2009-04-28 20:33:11 +00003276 // Look for any identifiers that were named while processing the
3277 // headers, but are otherwise not needed. We add these to the hash
3278 // table to enable checking of the predefines buffer in the case
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00003279 // where the user adds new macro definitions when building the AST
Douglas Gregore6648fb2009-04-28 20:33:11 +00003280 // file.
3281 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
3282 IDEnd = PP.getIdentifierTable().end();
3283 ID != IDEnd; ++ID)
3284 getIdentifierRef(ID->second);
3285
Sebastian Redlff4a2952010-07-23 23:49:55 +00003286 // Create the on-disk hash table representation. We only store offsets
3287 // for identifiers that appear here for the first time.
3288 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
Sebastian Redl539c5062010-08-18 23:57:32 +00003289 for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003290 ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end();
3291 ID != IDEnd; ++ID) {
3292 assert(ID->first && "NULL identifier in identifier table");
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003293 if (!Chain || !ID->first->isFromAST() ||
3294 ID->first->hasChangedSinceDeserialization())
Douglas Gregor8d7edce2013-02-08 21:30:59 +00003295 Generator.insert(const_cast<IdentifierInfo *>(ID->first), ID->second,
Douglas Gregor4a69c2e2011-09-01 17:04:32 +00003296 Trait);
Douglas Gregore84a9da2009-04-20 20:36:09 +00003297 }
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003298
Douglas Gregore84a9da2009-04-20 20:36:09 +00003299 // Create the on-disk hash table in a buffer.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003300 SmallString<4096> IdentifierTable;
Douglas Gregora868bbd2009-04-21 22:25:48 +00003301 uint32_t BucketOffset;
Douglas Gregore84a9da2009-04-20 20:36:09 +00003302 {
Justin Bognere1c147c2014-03-28 22:03:19 +00003303 using namespace llvm::support;
Douglas Gregor935bc7a22011-10-27 09:33:13 +00003304 ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
Douglas Gregore84a9da2009-04-20 20:36:09 +00003305 llvm::raw_svector_ostream Out(IdentifierTable);
Douglas Gregorc78d3462009-04-24 21:10:55 +00003306 // Make sure that no bucket is at offset 0
Justin Bognere1c147c2014-03-28 22:03:19 +00003307 endian::Writer<little>(Out).write<uint32_t>(0);
Douglas Gregora868bbd2009-04-21 22:25:48 +00003308 BucketOffset = Generator.Emit(Out, Trait);
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003309 }
3310
3311 // Create a blob abbreviation
3312 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00003313 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
Douglas Gregora868bbd2009-04-21 22:25:48 +00003314 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Douglas Gregore84a9da2009-04-20 20:36:09 +00003315 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
Douglas Gregor8f45df52009-04-16 22:23:12 +00003316 unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev);
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003317
3318 // Write the identifier table
3319 RecordData Record;
Sebastian Redl539c5062010-08-18 23:57:32 +00003320 Record.push_back(IDENTIFIER_TABLE);
Douglas Gregora868bbd2009-04-21 22:25:48 +00003321 Record.push_back(BucketOffset);
Daniel Dunbar8100d012009-08-24 09:31:37 +00003322 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str());
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003323 }
3324
3325 // Write the offsets table for identifier IDs.
Douglas Gregor0e149972009-04-25 19:10:14 +00003326 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Sebastian Redl539c5062010-08-18 23:57:32 +00003327 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
Douglas Gregor0e149972009-04-25 19:10:14 +00003328 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
Douglas Gregor1ab036c2011-08-03 21:49:18 +00003329 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
Douglas Gregor0e149972009-04-25 19:10:14 +00003330 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3331 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
3332
Douglas Gregor8d7edce2013-02-08 21:30:59 +00003333#ifndef NDEBUG
3334 for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
3335 assert(IdentifierOffsets[I] && "Missing identifier offset?");
3336#endif
3337
Douglas Gregor0e149972009-04-25 19:10:14 +00003338 RecordData Record;
Sebastian Redl539c5062010-08-18 23:57:32 +00003339 Record.push_back(IDENTIFIER_OFFSET);
Douglas Gregor0e149972009-04-25 19:10:14 +00003340 Record.push_back(IdentifierOffsets.size());
Douglas Gregor1ab036c2011-08-03 21:49:18 +00003341 Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS);
Douglas Gregor0e149972009-04-25 19:10:14 +00003342 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
Benjamin Kramerd47a12a2011-04-24 17:44:50 +00003343 data(IdentifierOffsets));
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00003344}
3345
Douglas Gregorc5046832009-04-27 18:38:38 +00003346//===----------------------------------------------------------------------===//
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003347// DeclContext's Name Lookup Table Serialization
3348//===----------------------------------------------------------------------===//
3349
3350namespace {
3351// Trait used for the on-disk hash table used in the method pool.
3352class ASTDeclContextNameLookupTrait {
3353 ASTWriter &Writer;
3354
3355public:
3356 typedef DeclarationName key_type;
3357 typedef key_type key_type_ref;
3358
3359 typedef DeclContext::lookup_result data_type;
3360 typedef const data_type& data_type_ref;
3361
Justin Bogner25463f12014-04-18 20:27:24 +00003362 typedef unsigned hash_value_type;
3363 typedef unsigned offset_type;
3364
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003365 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { }
3366
Justin Bogner25463f12014-04-18 20:27:24 +00003367 hash_value_type ComputeHash(DeclarationName Name) {
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003368 llvm::FoldingSetNodeID ID;
3369 ID.AddInteger(Name.getNameKind());
3370
3371 switch (Name.getNameKind()) {
3372 case DeclarationName::Identifier:
3373 ID.AddString(Name.getAsIdentifierInfo()->getName());
3374 break;
3375 case DeclarationName::ObjCZeroArgSelector:
3376 case DeclarationName::ObjCOneArgSelector:
3377 case DeclarationName::ObjCMultiArgSelector:
3378 ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector()));
3379 break;
3380 case DeclarationName::CXXConstructorName:
3381 case DeclarationName::CXXDestructorName:
3382 case DeclarationName::CXXConversionFunctionName:
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003383 break;
3384 case DeclarationName::CXXOperatorName:
3385 ID.AddInteger(Name.getCXXOverloadedOperator());
3386 break;
3387 case DeclarationName::CXXLiteralOperatorName:
3388 ID.AddString(Name.getCXXLiteralIdentifier()->getName());
3389 case DeclarationName::CXXUsingDirective:
3390 break;
3391 }
3392
3393 return ID.ComputeHash();
3394 }
3395
3396 std::pair<unsigned,unsigned>
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003397 EmitKeyDataLength(raw_ostream& Out, DeclarationName Name,
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003398 data_type_ref Lookup) {
Justin Bognere1c147c2014-03-28 22:03:19 +00003399 using namespace llvm::support;
3400 endian::Writer<little> LE(Out);
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003401 unsigned KeyLen = 1;
3402 switch (Name.getNameKind()) {
3403 case DeclarationName::Identifier:
3404 case DeclarationName::ObjCZeroArgSelector:
3405 case DeclarationName::ObjCOneArgSelector:
3406 case DeclarationName::ObjCMultiArgSelector:
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003407 case DeclarationName::CXXLiteralOperatorName:
3408 KeyLen += 4;
3409 break;
3410 case DeclarationName::CXXOperatorName:
3411 KeyLen += 1;
3412 break;
Douglas Gregor3b65ed02011-08-02 18:32:54 +00003413 case DeclarationName::CXXConstructorName:
3414 case DeclarationName::CXXDestructorName:
3415 case DeclarationName::CXXConversionFunctionName:
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003416 case DeclarationName::CXXUsingDirective:
3417 break;
3418 }
Justin Bognere1c147c2014-03-28 22:03:19 +00003419 LE.write<uint16_t>(KeyLen);
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003420
3421 // 2 bytes for num of decls and 4 for each DeclID.
David Blaikieff7d47a2012-12-19 00:45:41 +00003422 unsigned DataLen = 2 + 4 * Lookup.size();
Justin Bognere1c147c2014-03-28 22:03:19 +00003423 LE.write<uint16_t>(DataLen);
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003424
3425 return std::make_pair(KeyLen, DataLen);
3426 }
3427
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003428 void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) {
Justin Bognere1c147c2014-03-28 22:03:19 +00003429 using namespace llvm::support;
3430 endian::Writer<little> LE(Out);
3431 LE.write<uint8_t>(Name.getNameKind());
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003432 switch (Name.getNameKind()) {
3433 case DeclarationName::Identifier:
Justin Bognere1c147c2014-03-28 22:03:19 +00003434 LE.write<uint32_t>(Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
Benjamin Kramer53750b12012-09-19 13:40:40 +00003435 return;
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003436 case DeclarationName::ObjCZeroArgSelector:
3437 case DeclarationName::ObjCOneArgSelector:
3438 case DeclarationName::ObjCMultiArgSelector:
Justin Bognere1c147c2014-03-28 22:03:19 +00003439 LE.write<uint32_t>(Writer.getSelectorRef(Name.getObjCSelector()));
Benjamin Kramer53750b12012-09-19 13:40:40 +00003440 return;
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003441 case DeclarationName::CXXOperatorName:
Benjamin Kramer53750b12012-09-19 13:40:40 +00003442 assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS &&
3443 "Invalid operator?");
Justin Bognere1c147c2014-03-28 22:03:19 +00003444 LE.write<uint8_t>(Name.getCXXOverloadedOperator());
Benjamin Kramer53750b12012-09-19 13:40:40 +00003445 return;
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003446 case DeclarationName::CXXLiteralOperatorName:
Justin Bognere1c147c2014-03-28 22:03:19 +00003447 LE.write<uint32_t>(Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
Benjamin Kramer53750b12012-09-19 13:40:40 +00003448 return;
Douglas Gregor3b65ed02011-08-02 18:32:54 +00003449 case DeclarationName::CXXConstructorName:
3450 case DeclarationName::CXXDestructorName:
3451 case DeclarationName::CXXConversionFunctionName:
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003452 case DeclarationName::CXXUsingDirective:
Benjamin Kramer53750b12012-09-19 13:40:40 +00003453 return;
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003454 }
Benjamin Kramer53750b12012-09-19 13:40:40 +00003455
3456 llvm_unreachable("Invalid name kind?");
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003457 }
3458
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003459 void EmitData(raw_ostream& Out, key_type_ref,
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003460 data_type Lookup, unsigned DataLen) {
Justin Bognere1c147c2014-03-28 22:03:19 +00003461 using namespace llvm::support;
3462 endian::Writer<little> LE(Out);
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003463 uint64_t Start = Out.tell(); (void)Start;
Justin Bognere1c147c2014-03-28 22:03:19 +00003464 LE.write<uint16_t>(Lookup.size());
David Blaikieff7d47a2012-12-19 00:45:41 +00003465 for (DeclContext::lookup_iterator I = Lookup.begin(), E = Lookup.end();
3466 I != E; ++I)
Justin Bognere1c147c2014-03-28 22:03:19 +00003467 LE.write<uint32_t>(Writer.GetDeclRef(*I));
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003468
3469 assert(Out.tell() - Start == DataLen && "Data length is wrong");
3470 }
3471};
3472} // end anonymous namespace
3473
Richard Smith961eae52014-03-25 01:14:22 +00003474uint32_t
3475ASTWriter::GenerateNameLookupTable(const DeclContext *DC,
3476 llvm::SmallVectorImpl<char> &LookupTable) {
3477 assert(!DC->LookupPtr.getInt() && "must call buildLookups first");
3478 assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table");
3479
Justin Bognerbb094f02014-04-18 19:57:06 +00003480 llvm::OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait>
3481 Generator;
Richard Smith961eae52014-03-25 01:14:22 +00003482 ASTDeclContextNameLookupTrait Trait(*this);
3483
3484 // Create the on-disk hash table representation.
Stephan Tolksdorfa6a08632014-03-27 19:22:19 +00003485 DeclarationName ConstructorName;
Richard Smith961eae52014-03-25 01:14:22 +00003486 DeclarationName ConversionName;
Stephan Tolksdorfa6a08632014-03-27 19:22:19 +00003487 SmallVector<NamedDecl *, 8> ConstructorDecls;
Richard Smith961eae52014-03-25 01:14:22 +00003488 SmallVector<NamedDecl *, 4> ConversionDecls;
3489
3490 auto AddLookupResult = [&](DeclarationName Name,
3491 DeclContext::lookup_result Result) {
3492 if (Result.empty())
3493 return;
3494
Stephan Tolksdorfa6a08632014-03-27 19:22:19 +00003495 // Different DeclarationName values of certain kinds are mapped to
3496 // identical serialized keys, because we don't want to use type
3497 // identifiers in the keys (since type ids are local to the module).
3498 switch (Name.getNameKind()) {
3499 case DeclarationName::CXXConstructorName:
3500 // There may be different CXXConstructorName DeclarationName values
3501 // in a DeclContext because a UsingDecl that inherits constructors
3502 // has the DeclarationName of the inherited constructors.
3503 if (!ConstructorName)
3504 ConstructorName = Name;
3505 ConstructorDecls.append(Result.begin(), Result.end());
3506 return;
3507 case DeclarationName::CXXConversionFunctionName:
Richard Smith961eae52014-03-25 01:14:22 +00003508 if (!ConversionName)
3509 ConversionName = Name;
3510 ConversionDecls.append(Result.begin(), Result.end());
3511 return;
Stephan Tolksdorfa6a08632014-03-27 19:22:19 +00003512 default:
3513 break;
Richard Smith961eae52014-03-25 01:14:22 +00003514 }
3515
3516 Generator.insert(Name, Result, Trait);
3517 };
3518
3519 SmallVector<DeclarationName, 16> ExternalNames;
3520 for (auto &Lookup : *DC->getLookupPtr()) {
3521 if (Lookup.second.hasExternalDecls() ||
3522 DC->NeedToReconcileExternalVisibleStorage) {
3523 // We don't know for sure what declarations are found by this name,
3524 // because the external source might have a different set from the set
3525 // that are in the lookup map, and we can't update it now without
3526 // risking invalidating our lookup iterator. So add it to a queue to
3527 // deal with later.
3528 ExternalNames.push_back(Lookup.first);
3529 continue;
3530 }
3531
3532 AddLookupResult(Lookup.first, Lookup.second.getLookupResult());
3533 }
3534
3535 // Add the names we needed to defer. Note, this shouldn't add any new decls
3536 // to the list we need to serialize: any new declarations we find here should
3537 // be imported from an external source.
3538 // FIXME: What if the external source isn't an ASTReader?
3539 for (const auto &Name : ExternalNames)
3540 // FIXME: const_cast since OnDiskHashTable wants a non-const lookup result.
3541 AddLookupResult(Name, const_cast<DeclContext*>(DC)->lookup(Name));
3542
Stephan Tolksdorfa6a08632014-03-27 19:22:19 +00003543 // Add the constructors.
3544 if (!ConstructorDecls.empty()) {
3545 Generator.insert(ConstructorName,
3546 DeclContext::lookup_result(ConstructorDecls.begin(),
3547 ConstructorDecls.end()),
3548 Trait);
3549 }
3550 // Add the conversion functions.
Richard Smith961eae52014-03-25 01:14:22 +00003551 if (!ConversionDecls.empty()) {
3552 Generator.insert(ConversionName,
3553 DeclContext::lookup_result(ConversionDecls.begin(),
3554 ConversionDecls.end()),
3555 Trait);
3556 }
3557
3558 // Create the on-disk hash table in a buffer.
3559 llvm::raw_svector_ostream Out(LookupTable);
3560 // Make sure that no bucket is at offset 0
Justin Bognere1c147c2014-03-28 22:03:19 +00003561 using namespace llvm::support;
3562 endian::Writer<little>(Out).write<uint32_t>(0);
Richard Smith961eae52014-03-25 01:14:22 +00003563 return Generator.Emit(Out, Trait);
3564}
3565
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00003566/// \brief Write the block containing all of the declaration IDs
3567/// visible from the given DeclContext.
3568///
3569/// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
Sebastian Redla4071b42010-08-24 00:50:09 +00003570/// bitstream, or 0 if no block was written.
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00003571uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
3572 DeclContext *DC) {
3573 if (DC->getPrimaryContext() != DC)
3574 return 0;
3575
3576 // Since there is no name lookup into functions or methods, don't bother to
3577 // build a visible-declarations table for these entities.
3578 if (DC->isFunctionOrMethod())
3579 return 0;
3580
3581 // If not in C++, we perform name lookup for the translation unit via the
3582 // IdentifierInfo chains, don't bother to build a visible-declarations table.
David Blaikiebbafb8a2012-03-11 07:00:24 +00003583 if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus)
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00003584 return 0;
3585
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00003586 // Serialize the contents of the mapping used for lookup. Note that,
3587 // although we have two very different code paths, the serialized
3588 // representation is the same for both cases: a declaration name,
3589 // followed by a size, followed by references to the visible
3590 // declarations that have that name.
3591 uint64_t Offset = Stream.GetCurrentBitNo();
Richard Smithf634c902012-03-16 06:12:59 +00003592 StoredDeclsMap *Map = DC->buildLookup();
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00003593 if (!Map || Map->empty())
3594 return 0;
3595
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00003596 // Create the on-disk hash table in a buffer.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003597 SmallString<4096> LookupTable;
Richard Smith961eae52014-03-25 01:14:22 +00003598 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable);
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00003599
3600 // Write the lookup table
3601 RecordData Record;
3602 Record.push_back(DECL_CONTEXT_VISIBLE);
3603 Record.push_back(BucketOffset);
3604 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
3605 LookupTable.str());
3606
3607 Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record);
3608 ++NumVisibleDeclContexts;
3609 return Offset;
3610}
3611
Sebastian Redla4071b42010-08-24 00:50:09 +00003612/// \brief Write an UPDATE_VISIBLE block for the given context.
3613///
3614/// UPDATE_VISIBLE blocks contain the declarations that are added to an existing
3615/// DeclContext in a dependent AST file. As such, they only exist for the TU
Richard Smithf634c902012-03-16 06:12:59 +00003616/// (in C++), for namespaces, and for classes with forward-declared unscoped
3617/// enumeration members (in C++11).
Sebastian Redla4071b42010-08-24 00:50:09 +00003618void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
Richard Smith961eae52014-03-25 01:14:22 +00003619 StoredDeclsMap *Map = DC->getLookupPtr();
Sebastian Redla4071b42010-08-24 00:50:09 +00003620 if (!Map || Map->empty())
3621 return;
3622
Sebastian Redla4071b42010-08-24 00:50:09 +00003623 // Create the on-disk hash table in a buffer.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003624 SmallString<4096> LookupTable;
Richard Smith961eae52014-03-25 01:14:22 +00003625 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable);
Sebastian Redla4071b42010-08-24 00:50:09 +00003626
3627 // Write the lookup table
3628 RecordData Record;
3629 Record.push_back(UPDATE_VISIBLE);
3630 Record.push_back(getDeclID(cast<Decl>(DC)));
3631 Record.push_back(BucketOffset);
3632 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str());
3633}
3634
Peter Collingbourne5df20e02011-02-15 19:46:30 +00003635/// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions.
3636void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) {
3637 RecordData Record;
3638 Record.push_back(Opts.fp_contract);
3639 Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record);
3640}
3641
3642/// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions.
3643void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00003644 if (!SemaRef.Context.getLangOpts().OpenCL)
Peter Collingbourne5df20e02011-02-15 19:46:30 +00003645 return;
3646
3647 const OpenCLOptions &Opts = SemaRef.getOpenCLOptions();
3648 RecordData Record;
3649#define OPENCLEXT(nm) Record.push_back(Opts.nm);
3650#include "clang/Basic/OpenCLExtensions.def"
3651 Stream.EmitRecord(OPENCL_EXTENSIONS, Record);
3652}
3653
Douglas Gregor358cd442012-01-15 16:58:34 +00003654void ASTWriter::WriteRedeclarations() {
3655 RecordData LocalRedeclChains;
3656 SmallVector<serialization::LocalRedeclarationsInfo, 2> LocalRedeclsMap;
3657
3658 for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) {
3659 Decl *First = Redeclarations[I];
Rafael Espindola3f9e4442013-10-19 02:13:21 +00003660 assert(First->isFirstDecl() && "Not the first declaration?");
Douglas Gregor358cd442012-01-15 16:58:34 +00003661
3662 Decl *MostRecent = First->getMostRecentDecl();
3663
3664 // If we only have a single declaration, there is no point in storing
3665 // a redeclaration chain.
3666 if (First == MostRecent)
3667 continue;
3668
3669 unsigned Offset = LocalRedeclChains.size();
3670 unsigned Size = 0;
3671 LocalRedeclChains.push_back(0); // Placeholder for the size.
3672
3673 // Collect the set of local redeclarations of this declaration.
Douglas Gregor6168bd22013-02-18 15:53:43 +00003674 for (Decl *Prev = MostRecent; Prev != First;
Douglas Gregor358cd442012-01-15 16:58:34 +00003675 Prev = Prev->getPreviousDecl()) {
3676 if (!Prev->isFromASTFile()) {
3677 AddDeclRef(Prev, LocalRedeclChains);
3678 ++Size;
3679 }
3680 }
Douglas Gregor6168bd22013-02-18 15:53:43 +00003681
3682 if (!First->isFromASTFile() && Chain) {
3683 Decl *FirstFromAST = MostRecent;
3684 for (Decl *Prev = MostRecent; Prev; Prev = Prev->getPreviousDecl()) {
3685 if (Prev->isFromASTFile())
3686 FirstFromAST = Prev;
3687 }
3688
3689 Chain->MergedDecls[FirstFromAST].push_back(getDeclID(First));
3690 }
3691
Douglas Gregor358cd442012-01-15 16:58:34 +00003692 LocalRedeclChains[Offset] = Size;
3693
3694 // Reverse the set of local redeclarations, so that we store them in
3695 // order (since we found them in reverse order).
3696 std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end());
3697
Douglas Gregor6168bd22013-02-18 15:53:43 +00003698 // Add the mapping from the first ID from the AST to the set of local
3699 // declarations.
Douglas Gregor358cd442012-01-15 16:58:34 +00003700 LocalRedeclarationsInfo Info = { getDeclID(First), Offset };
3701 LocalRedeclsMap.push_back(Info);
3702
3703 assert(N == Redeclarations.size() &&
3704 "Deserialized a declaration we shouldn't have");
3705 }
3706
3707 if (LocalRedeclChains.empty())
3708 return;
3709
3710 // Sort the local redeclarations map by the first declaration ID,
3711 // since the reader will be performing binary searches on this information.
3712 llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end());
3713
3714 // Emit the local redeclarations map.
3715 using namespace llvm;
3716 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3717 Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP));
3718 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
3719 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3720 unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
3721
3722 RecordData Record;
3723 Record.push_back(LOCAL_REDECLARATIONS_MAP);
3724 Record.push_back(LocalRedeclsMap.size());
3725 Stream.EmitRecordWithBlob(AbbrevID, Record,
3726 reinterpret_cast<char*>(LocalRedeclsMap.data()),
3727 LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo));
3728
3729 // Emit the redeclaration chains.
3730 Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains);
3731}
3732
Douglas Gregor404cdde2012-01-27 01:47:08 +00003733void ASTWriter::WriteObjCCategories() {
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003734 SmallVector<ObjCCategoriesInfo, 2> CategoriesMap;
Douglas Gregor404cdde2012-01-27 01:47:08 +00003735 RecordData Categories;
3736
3737 for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
3738 unsigned Size = 0;
3739 unsigned StartIndex = Categories.size();
3740
3741 ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I];
3742
3743 // Allocate space for the size.
3744 Categories.push_back(0);
3745
3746 // Add the categories.
Douglas Gregor048fbfa2013-01-16 23:00:23 +00003747 for (ObjCInterfaceDecl::known_categories_iterator
3748 Cat = Class->known_categories_begin(),
3749 CatEnd = Class->known_categories_end();
3750 Cat != CatEnd; ++Cat, ++Size) {
3751 assert(getDeclID(*Cat) != 0 && "Bogus category");
3752 AddDeclRef(*Cat, Categories);
Douglas Gregor404cdde2012-01-27 01:47:08 +00003753 }
3754
3755 // Update the size.
3756 Categories[StartIndex] = Size;
3757
3758 // Record this interface -> category map.
3759 ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex };
3760 CategoriesMap.push_back(CatInfo);
3761 }
3762
3763 // Sort the categories map by the definition ID, since the reader will be
3764 // performing binary searches on this information.
3765 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
3766
3767 // Emit the categories map.
3768 using namespace llvm;
3769 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3770 Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP));
3771 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
3772 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3773 unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
3774
3775 RecordData Record;
3776 Record.push_back(OBJC_CATEGORIES_MAP);
3777 Record.push_back(CategoriesMap.size());
3778 Stream.EmitRecordWithBlob(AbbrevID, Record,
3779 reinterpret_cast<char*>(CategoriesMap.data()),
3780 CategoriesMap.size() * sizeof(ObjCCategoriesInfo));
3781
3782 // Emit the category lists.
3783 Stream.EmitRecord(OBJC_CATEGORIES, Categories);
3784}
3785
Douglas Gregor464b0ca2011-12-22 21:40:42 +00003786void ASTWriter::WriteMergedDecls() {
3787 if (!Chain || Chain->MergedDecls.empty())
3788 return;
3789
3790 RecordData Record;
3791 for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(),
3792 IEnd = Chain->MergedDecls.end();
3793 I != IEnd; ++I) {
Douglas Gregor64af53c2012-01-05 22:27:05 +00003794 DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID()
Douglas Gregor464b0ca2011-12-22 21:40:42 +00003795 : getDeclID(I->first);
3796 assert(CanonID && "Merged declaration not known?");
3797
3798 Record.push_back(CanonID);
3799 Record.push_back(I->second.size());
3800 Record.append(I->second.begin(), I->second.end());
3801 }
3802 Stream.EmitRecord(MERGED_DECLARATIONS, Record);
3803}
3804
Richard Smithe40f2ba2013-08-07 21:41:30 +00003805void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) {
3806 Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap;
3807
3808 if (LPTMap.empty())
3809 return;
3810
3811 RecordData Record;
3812 for (Sema::LateParsedTemplateMapT::iterator It = LPTMap.begin(),
3813 ItEnd = LPTMap.end();
3814 It != ItEnd; ++It) {
3815 LateParsedTemplate *LPT = It->second;
3816 AddDeclRef(It->first, Record);
3817 AddDeclRef(LPT->D, Record);
3818 Record.push_back(LPT->Toks.size());
3819
3820 for (CachedTokens::iterator TokIt = LPT->Toks.begin(),
3821 TokEnd = LPT->Toks.end();
3822 TokIt != TokEnd; ++TokIt) {
3823 AddToken(*TokIt, Record);
3824 }
3825 }
3826 Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record);
3827}
3828
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00003829//===----------------------------------------------------------------------===//
Douglas Gregorc5046832009-04-27 18:38:38 +00003830// General Serialization Routines
3831//===----------------------------------------------------------------------===//
3832
Douglas Gregorbc8a78d52009-04-15 21:30:51 +00003833/// \brief Write a record containing the given attributes.
Alexander Kornienko20f6fc62012-07-09 10:04:07 +00003834void ASTWriter::WriteAttributes(ArrayRef<const Attr*> Attrs,
3835 RecordDataImpl &Record) {
Argyrios Kyrtzidis9beef8e2010-10-18 19:20:11 +00003836 Record.push_back(Attrs.size());
Alexander Kornienko20f6fc62012-07-09 10:04:07 +00003837 for (ArrayRef<const Attr *>::iterator i = Attrs.begin(),
3838 e = Attrs.end(); i != e; ++i){
3839 const Attr *A = *i;
Alexis Huntdcfba7b2010-08-18 23:23:40 +00003840 Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
Argyrios Kyrtzidis309b4c42011-09-13 16:05:58 +00003841 AddSourceRange(A->getRange(), Record);
Douglas Gregorbc8a78d52009-04-15 21:30:51 +00003842
Alexis Huntdcfba7b2010-08-18 23:23:40 +00003843#include "clang/Serialization/AttrPCHWrite.inc"
Daniel Dunbarfc6507e2010-05-27 02:25:39 +00003844
Douglas Gregorbc8a78d52009-04-15 21:30:51 +00003845 }
Douglas Gregorbc8a78d52009-04-15 21:30:51 +00003846}
3847
John McCallf413f5e2013-05-03 00:10:13 +00003848void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) {
3849 AddSourceLocation(Tok.getLocation(), Record);
3850 Record.push_back(Tok.getLength());
3851
3852 // FIXME: When reading literal tokens, reconstruct the literal pointer
3853 // if it is needed.
3854 AddIdentifierRef(Tok.getIdentifierInfo(), Record);
3855 // FIXME: Should translate token kind to a stable encoding.
3856 Record.push_back(Tok.getKind());
3857 // FIXME: Should translate token flags to a stable encoding.
3858 Record.push_back(Tok.getFlags());
3859}
3860
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003861void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) {
Douglas Gregorbc8a78d52009-04-15 21:30:51 +00003862 Record.push_back(Str.size());
3863 Record.insert(Record.end(), Str.begin(), Str.end());
3864}
3865
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00003866void ASTWriter::AddVersionTuple(const VersionTuple &Version,
3867 RecordDataImpl &Record) {
3868 Record.push_back(Version.getMajor());
David Blaikie05785d12013-02-20 22:23:23 +00003869 if (Optional<unsigned> Minor = Version.getMinor())
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00003870 Record.push_back(*Minor + 1);
3871 else
3872 Record.push_back(0);
David Blaikie05785d12013-02-20 22:23:23 +00003873 if (Optional<unsigned> Subminor = Version.getSubminor())
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00003874 Record.push_back(*Subminor + 1);
3875 else
3876 Record.push_back(0);
3877}
3878
Douglas Gregore84a9da2009-04-20 20:36:09 +00003879/// \brief Note that the identifier II occurs at the given offset
3880/// within the identifier table.
Sebastian Redl55c0ad52010-08-18 23:56:21 +00003881void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
Sebastian Redl539c5062010-08-18 23:57:32 +00003882 IdentID ID = IdentifierIDs[II];
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00003883 // Only store offsets new to this AST file. Other identifier names are looked
Sebastian Redlff4a2952010-07-23 23:49:55 +00003884 // up earlier in the chain and thus don't need an offset.
3885 if (ID >= FirstIdentID)
3886 IdentifierOffsets[ID - FirstIdentID] = Offset;
Douglas Gregore84a9da2009-04-20 20:36:09 +00003887}
3888
Douglas Gregor95c13f52009-04-25 17:48:32 +00003889/// \brief Note that the selector Sel occurs at the given offset
3890/// within the method pool/selector table.
Sebastian Redl55c0ad52010-08-18 23:56:21 +00003891void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
Douglas Gregor95c13f52009-04-25 17:48:32 +00003892 unsigned ID = SelectorIDs[Sel];
3893 assert(ID && "Unknown selector");
Sebastian Redld95a56e2010-08-04 18:21:41 +00003894 // Don't record offsets for selectors that are also available in a different
3895 // file.
3896 if (ID < FirstSelectorID)
3897 return;
3898 SelectorOffsets[ID - FirstSelectorID] = Offset;
Douglas Gregor95c13f52009-04-25 17:48:32 +00003899}
3900
Sebastian Redl55c0ad52010-08-18 23:56:21 +00003901ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream)
Douglas Gregora89c5ac2011-12-06 01:10:29 +00003902 : Stream(Stream), Context(0), PP(0), Chain(0), WritingModule(0),
Argyrios Kyrtzidis442dd802012-07-02 19:19:01 +00003903 WritingAST(false), DoneWritingDeclsAndTypes(false),
3904 ASTHasCompilerErrors(false),
Douglas Gregor6f8912e2011-08-03 16:05:40 +00003905 FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID),
Sebastian Redl539c5062010-08-18 23:57:32 +00003906 FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID),
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00003907 FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID),
3908 FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID),
Douglas Gregor253eefe2011-12-01 00:59:36 +00003909 FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS),
3910 NextSubmoduleID(FirstSubmoduleID),
Douglas Gregor8f364fb2011-08-03 23:28:44 +00003911 FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID),
Douglas Gregor91096292010-10-02 19:29:26 +00003912 CollectedStmts(&StmtsToEmit),
Sebastian Redld95a56e2010-08-04 18:21:41 +00003913 NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0),
Douglas Gregor03412ba2011-06-03 02:27:19 +00003914 NumVisibleDeclContexts(0),
Douglas Gregorc27b2872011-08-04 00:01:48 +00003915 NextCXXBaseSpecifiersID(1),
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00003916 DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0),
Douglas Gregor03412ba2011-06-03 02:27:19 +00003917 DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0),
3918 DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0),
3919 DeclRecordAbbrev(0), IntegerLiteralAbbrev(0),
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00003920 DeclTypedefAbbrev(0),
3921 DeclVarAbbrev(0), DeclFieldAbbrev(0),
3922 DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0)
Douglas Gregord4c5ed02010-10-29 22:39:52 +00003923{
Sebastian Redl85b2a6a2010-07-14 23:45:08 +00003924}
Douglas Gregoref84c4b2009-04-09 22:27:44 +00003925
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00003926ASTWriter::~ASTWriter() {
Reid Kleckner588c9372014-02-19 23:44:52 +00003927 llvm::DeleteContainerSeconds(FileDeclIDs);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00003928}
3929
Argyrios Kyrtzidisd7c16b22012-10-31 20:59:50 +00003930void ASTWriter::WriteAST(Sema &SemaRef,
Argyrios Kyrtzidis10b23682011-02-15 17:54:22 +00003931 const std::string &OutputFile,
Argyrios Kyrtzidis4a280ff2012-03-07 01:51:17 +00003932 Module *WritingModule, StringRef isysroot,
3933 bool hasErrors) {
Douglas Gregor2fd3d402011-09-17 00:05:03 +00003934 WritingAST = true;
3935
Argyrios Kyrtzidis4a280ff2012-03-07 01:51:17 +00003936 ASTHasCompilerErrors = hasErrors;
3937
Douglas Gregoref84c4b2009-04-09 22:27:44 +00003938 // Emit the file header.
Douglas Gregor8f45df52009-04-16 22:23:12 +00003939 Stream.Emit((unsigned)'C', 8);
3940 Stream.Emit((unsigned)'P', 8);
3941 Stream.Emit((unsigned)'C', 8);
3942 Stream.Emit((unsigned)'H', 8);
Mike Stump11289f42009-09-09 15:08:12 +00003943
Chris Lattner28fa4e62009-04-26 22:26:21 +00003944 WriteBlockInfoBlock();
Douglas Gregoref84c4b2009-04-09 22:27:44 +00003945
Douglas Gregoreda8e122011-08-09 15:13:55 +00003946 Context = &SemaRef.Context;
Douglas Gregora28bcdd2011-12-01 02:07:58 +00003947 PP = &SemaRef.PP;
Douglas Gregora89c5ac2011-12-06 01:10:29 +00003948 this->WritingModule = WritingModule;
Argyrios Kyrtzidisd7c16b22012-10-31 20:59:50 +00003949 WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule);
Douglas Gregoreda8e122011-08-09 15:13:55 +00003950 Context = 0;
Douglas Gregora28bcdd2011-12-01 02:07:58 +00003951 PP = 0;
Douglas Gregora89c5ac2011-12-06 01:10:29 +00003952 this->WritingModule = 0;
Douglas Gregor2fd3d402011-09-17 00:05:03 +00003953
3954 WritingAST = false;
Sebastian Redl143413f2010-07-12 22:02:52 +00003955}
3956
Douglas Gregora94a1542011-07-27 21:45:57 +00003957template<typename Vector>
3958static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec,
3959 ASTWriter::RecordData &Record) {
3960 for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end();
3961 I != E; ++I) {
3962 Writer.AddDeclRef(*I, Record);
3963 }
3964}
3965
Argyrios Kyrtzidisd7c16b22012-10-31 20:59:50 +00003966void ASTWriter::WriteASTCore(Sema &SemaRef,
Douglas Gregorc567ba22011-07-22 16:35:34 +00003967 StringRef isysroot,
Douglas Gregorf7a700fd2011-11-30 04:39:39 +00003968 const std::string &OutputFile,
Douglas Gregorde3ef502011-11-30 23:21:26 +00003969 Module *WritingModule) {
Sebastian Redl143413f2010-07-12 22:02:52 +00003970 using namespace llvm;
3971
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +00003972 bool isModule = WritingModule != 0;
3973
Douglas Gregorcf68c582011-12-01 22:20:10 +00003974 // Make sure that the AST reader knows to finalize itself.
3975 if (Chain)
3976 Chain->finalizeForWriting();
3977
Sebastian Redl143413f2010-07-12 22:02:52 +00003978 ASTContext &Context = SemaRef.Context;
3979 Preprocessor &PP = SemaRef.PP;
3980
Douglas Gregordab42432011-08-12 00:15:20 +00003981 // Set up predefined declaration IDs.
3982 DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID;
Douglas Gregor3ea72692011-08-12 05:46:01 +00003983 if (Context.ObjCIdDecl)
3984 DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID;
Douglas Gregor52e02802011-08-12 06:17:30 +00003985 if (Context.ObjCSelDecl)
3986 DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID;
Douglas Gregor0a586182011-08-12 05:59:41 +00003987 if (Context.ObjCClassDecl)
3988 DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID;
Douglas Gregord53ae832012-01-17 18:09:05 +00003989 if (Context.ObjCProtocolClassDecl)
3990 DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID;
Douglas Gregor801c99d2011-08-12 06:49:56 +00003991 if (Context.Int128Decl)
3992 DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID;
3993 if (Context.UInt128Decl)
3994 DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID;
Douglas Gregorbab8a962011-09-08 01:46:34 +00003995 if (Context.ObjCInstanceTypeDecl)
3996 DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID;
Meador Inge5d3fb222012-06-16 03:34:49 +00003997 if (Context.BuiltinVaListDecl)
3998 DeclIDs[Context.getBuiltinVaListDecl()] = PREDEF_DECL_BUILTIN_VA_LIST_ID;
3999
Douglas Gregor851443c2011-08-12 01:39:19 +00004000 if (!Chain) {
4001 // Make sure that we emit IdentifierInfos (and any attached
4002 // declarations) for builtins. We don't need to do this when we're
4003 // emitting chained PCH files, because all of the builtins will be
4004 // in the original PCH file.
4005 // FIXME: Modules won't like this at all.
Douglas Gregor4621c6a2009-04-22 18:49:13 +00004006 IdentifierTable &Table = PP.getIdentifierTable();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004007 SmallVector<const char *, 32> BuiltinNames;
Eli Benderskye3cef2a2013-07-11 16:53:04 +00004008 if (!Context.getLangOpts().NoBuiltin) {
4009 Context.BuiltinInfo.GetBuiltinNames(BuiltinNames);
4010 }
Douglas Gregor4621c6a2009-04-22 18:49:13 +00004011 for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I)
4012 getIdentifierRef(&Table.get(BuiltinNames[I]));
4013 }
4014
Douglas Gregor935bc7a22011-10-27 09:33:13 +00004015 // If there are any out-of-date identifiers, bring them up to date.
4016 if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) {
Douglas Gregore68cf272013-01-07 16:56:53 +00004017 // Find out-of-date identifiers.
4018 SmallVector<IdentifierInfo *, 4> OutOfDate;
Douglas Gregor935bc7a22011-10-27 09:33:13 +00004019 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
4020 IDEnd = PP.getIdentifierTable().end();
Douglas Gregore68cf272013-01-07 16:56:53 +00004021 ID != IDEnd; ++ID) {
Douglas Gregor935bc7a22011-10-27 09:33:13 +00004022 if (ID->second->isOutOfDate())
Douglas Gregore68cf272013-01-07 16:56:53 +00004023 OutOfDate.push_back(ID->second);
4024 }
4025
4026 // Update the out-of-date identifiers.
4027 for (unsigned I = 0, N = OutOfDate.size(); I != N; ++I) {
4028 ExtSource->updateOutOfDateIdentifier(*OutOfDate[I]);
4029 }
Douglas Gregor935bc7a22011-10-27 09:33:13 +00004030 }
4031
Chris Lattner0c797362009-09-08 18:19:27 +00004032 // Build a record containing all of the tentative definitions in this file, in
Sebastian Redl35351a92010-01-31 22:27:38 +00004033 // TentativeDefinitions order. Generally, this record will be empty for
Chris Lattner0c797362009-09-08 18:19:27 +00004034 // headers.
Douglas Gregord4df8652009-04-22 22:02:47 +00004035 RecordData TentativeDefinitions;
Douglas Gregora94a1542011-07-27 21:45:57 +00004036 AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
Douglas Gregoreb08bd42011-07-27 20:58:46 +00004037
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00004038 // Build a record containing all of the file scoped decls in this file.
4039 RecordData UnusedFileScopedDecls;
Argyrios Kyrtzidis59852362013-03-14 04:45:00 +00004040 if (!isModule)
4041 AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls,
4042 UnusedFileScopedDecls);
Sebastian Redl08aca90252010-08-05 18:21:25 +00004043
Douglas Gregor851443c2011-08-12 01:39:19 +00004044 // Build a record containing all of the delegating constructors we still need
4045 // to resolve.
Alexis Hunt27a761d2011-05-04 23:29:54 +00004046 RecordData DelegatingCtorDecls;
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +00004047 if (!isModule)
4048 AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls);
Alexis Hunt27a761d2011-05-04 23:29:54 +00004049
Douglas Gregor851443c2011-08-12 01:39:19 +00004050 // Write the set of weak, undeclared identifiers. We always write the
4051 // entire table, since later PCH files in a PCH chain are only interested in
4052 // the results at the end of the chain.
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +00004053 RecordData WeakUndeclaredIdentifiers;
4054 if (!SemaRef.WeakUndeclaredIdentifiers.empty()) {
Douglas Gregor1c4bfe52011-07-28 18:09:57 +00004055 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +00004056 I = SemaRef.WeakUndeclaredIdentifiers.begin(),
4057 E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) {
4058 AddIdentifierRef(I->first, WeakUndeclaredIdentifiers);
4059 AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers);
4060 AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers);
4061 WeakUndeclaredIdentifiers.push_back(I->second.getUsed());
4062 }
4063 }
Kovarththanan Rajaratnama9c81a82010-03-14 07:06:50 +00004064
Richard Smith78165b52013-01-10 23:43:47 +00004065 // Build a record containing all of the locally-scoped extern "C"
Douglas Gregoracfc76c2009-04-22 22:18:58 +00004066 // declarations in this header file. Generally, this record will be
4067 // empty.
Richard Smith78165b52013-01-10 23:43:47 +00004068 RecordData LocallyScopedExternCDecls;
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00004069 // FIXME: This is filling in the AST file in densemap order which is
Chris Lattner0c797362009-09-08 18:19:27 +00004070 // nondeterminstic!
Mike Stump11289f42009-09-09 15:08:12 +00004071 for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
Richard Smith78165b52013-01-10 23:43:47 +00004072 TD = SemaRef.LocallyScopedExternCDecls.begin(),
4073 TDEnd = SemaRef.LocallyScopedExternCDecls.end();
Douglas Gregordc5c9582011-07-28 14:20:37 +00004074 TD != TDEnd; ++TD) {
Douglas Gregorb3722e22011-09-09 23:01:35 +00004075 if (!TD->second->isFromASTFile())
Richard Smith78165b52013-01-10 23:43:47 +00004076 AddDeclRef(TD->second, LocallyScopedExternCDecls);
Douglas Gregordc5c9582011-07-28 14:20:37 +00004077 }
4078
Douglas Gregor61cac2b2009-04-27 20:06:05 +00004079 // Build a record containing all of the ext_vector declarations.
4080 RecordData ExtVectorDecls;
Douglas Gregorb7098a32011-07-28 00:39:29 +00004081 AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls);
Douglas Gregor61cac2b2009-04-27 20:06:05 +00004082
Argyrios Kyrtzidisaf2eac22010-07-06 15:37:04 +00004083 // Build a record containing all of the VTable uses information.
4084 RecordData VTableUses;
Argyrios Kyrtzidisedee67f2010-08-03 17:29:52 +00004085 if (!SemaRef.VTableUses.empty()) {
Argyrios Kyrtzidisedee67f2010-08-03 17:29:52 +00004086 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
4087 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
4088 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
4089 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
4090 }
Argyrios Kyrtzidisaf2eac22010-07-06 15:37:04 +00004091 }
4092
4093 // Build a record containing all of dynamic classes declarations.
4094 RecordData DynamicClasses;
Douglas Gregor32002192011-07-28 00:53:40 +00004095 AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses);
Argyrios Kyrtzidisaf2eac22010-07-06 15:37:04 +00004096
Argyrios Kyrtzidis7f76d112010-08-05 09:48:16 +00004097 // Build a record containing all of pending implicit instantiations.
Chandler Carruth54080172010-08-25 08:44:16 +00004098 RecordData PendingInstantiations;
Argyrios Kyrtzidis7f76d112010-08-05 09:48:16 +00004099 for (std::deque<Sema::PendingImplicitInstantiation>::iterator
Chandler Carruth54080172010-08-25 08:44:16 +00004100 I = SemaRef.PendingInstantiations.begin(),
4101 N = SemaRef.PendingInstantiations.end(); I != N; ++I) {
4102 AddDeclRef(I->first, PendingInstantiations);
4103 AddSourceLocation(I->second, PendingInstantiations);
Argyrios Kyrtzidis7f76d112010-08-05 09:48:16 +00004104 }
4105 assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
4106 "There are local ones at end of translation unit!");
4107
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00004108 // Build a record containing some declaration references.
4109 RecordData SemaDeclRefs;
4110 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) {
4111 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs);
4112 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs);
4113 }
4114
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00004115 RecordData CUDASpecialDeclRefs;
4116 if (Context.getcudaConfigureCallDecl()) {
4117 AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs);
4118 }
4119
Douglas Gregorc2fa1692011-06-28 16:20:02 +00004120 // Build a record containing all of the known namespaces.
4121 RecordData KnownNamespaces;
Nick Lewycky8334af82013-01-26 00:35:08 +00004122 for (llvm::MapVector<NamespaceDecl*, bool>::iterator
Douglas Gregorc2fa1692011-06-28 16:20:02 +00004123 I = SemaRef.KnownNamespaces.begin(),
4124 IEnd = SemaRef.KnownNamespaces.end();
4125 I != IEnd; ++I) {
4126 if (!I->second)
4127 AddDeclRef(I->first, KnownNamespaces);
4128 }
Douglas Gregor112b9072012-10-18 05:31:06 +00004129
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00004130 // Build a record of all used, undefined objects that require definitions.
4131 RecordData UndefinedButUsed;
Nick Lewyckyf0f56162013-01-31 03:23:57 +00004132
4133 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00004134 SemaRef.getUndefinedButUsed(Undefined);
Nick Lewyckyf0f56162013-01-31 03:23:57 +00004135 for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator
4136 I = Undefined.begin(), E = Undefined.end(); I != E; ++I) {
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00004137 AddDeclRef(I->first, UndefinedButUsed);
4138 AddSourceLocation(I->second, UndefinedButUsed);
Nick Lewycky8334af82013-01-26 00:35:08 +00004139 }
4140
Douglas Gregor112b9072012-10-18 05:31:06 +00004141 // Write the control block
Douglas Gregor2d302362012-10-24 16:50:34 +00004142 WriteControlBlock(PP, Context, isysroot, OutputFile);
Douglas Gregor112b9072012-10-18 05:31:06 +00004143
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00004144 // Write the remaining AST contents.
Douglas Gregor652d82a2009-04-18 05:55:16 +00004145 RecordData Record;
Sebastian Redl539c5062010-08-18 23:57:32 +00004146 Stream.EnterSubblock(AST_BLOCK_ID, 5);
Douglas Gregor851443c2011-08-12 01:39:19 +00004147
Argyrios Kyrtzidis39605402012-12-13 21:38:23 +00004148 // This is so that older clang versions, before the introduction
4149 // of the control block, can read and reject the newer PCH format.
4150 Record.clear();
4151 Record.push_back(VERSION_MAJOR);
4152 Stream.EmitRecord(METADATA_OLD_FORMAT, Record);
4153
Douglas Gregor851443c2011-08-12 01:39:19 +00004154 // Create a lexical update block containing all of the declarations in the
4155 // translation unit that do not come from other AST files.
4156 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
4157 SmallVector<KindDeclIDPair, 64> NewGlobalDecls;
Aaron Ballman629afae2014-03-07 19:56:05 +00004158 for (const auto *I : TU->noload_decls()) {
4159 if (!I->isFromASTFile())
4160 NewGlobalDecls.push_back(std::make_pair(I->getKind(), GetDeclRef(I)));
Douglas Gregor851443c2011-08-12 01:39:19 +00004161 }
4162
4163 llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev();
4164 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
4165 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4166 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv);
4167 Record.clear();
4168 Record.push_back(TU_UPDATE_LEXICAL);
4169 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
4170 data(NewGlobalDecls));
4171
4172 // And a visible updates block for the translation unit.
4173 Abv = new llvm::BitCodeAbbrev();
4174 Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE));
4175 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4176 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32));
4177 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4178 UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv);
4179 WriteDeclContextVisibleUpdate(TU);
4180
4181 // If the translation unit has an anonymous namespace, and we don't already
4182 // have an update block for it, write it as an update block.
Richard Smith6ef42932014-03-20 21:02:00 +00004183 // FIXME: Why do we not do this if there's already an update block?
Douglas Gregor851443c2011-08-12 01:39:19 +00004184 if (NamespaceDecl *NS = TU->getAnonymousNamespace()) {
4185 ASTWriter::UpdateRecord &Record = DeclUpdates[TU];
Richard Smith6ef42932014-03-20 21:02:00 +00004186 if (Record.empty())
Aaron Ballman4f45b712014-03-21 15:22:56 +00004187 Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS));
Douglas Gregor851443c2011-08-12 01:39:19 +00004188 }
Argyrios Kyrtzidis442dd802012-07-02 19:19:01 +00004189
Richard Smith5652c0f2014-03-21 01:48:23 +00004190 // Add update records for all mangling numbers and static local numbers.
4191 // These aren't really update records, but this is a convenient way of
4192 // tagging this rare extra data onto the declarations.
4193 for (const auto &Number : Context.MangleNumbers)
4194 if (!Number.first->isFromASTFile())
Aaron Ballman4f45b712014-03-21 15:22:56 +00004195 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER,
4196 Number.second));
Richard Smith5652c0f2014-03-21 01:48:23 +00004197 for (const auto &Number : Context.StaticLocalNumbers)
4198 if (!Number.first->isFromASTFile())
Aaron Ballman4f45b712014-03-21 15:22:56 +00004199 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER,
4200 Number.second));
Richard Smith5652c0f2014-03-21 01:48:23 +00004201
Argyrios Kyrtzidis442dd802012-07-02 19:19:01 +00004202 // Make sure visible decls, added to DeclContexts previously loaded from
4203 // an AST file, are registered for serialization.
Craig Topper2341c0d2013-07-04 03:08:24 +00004204 for (SmallVectorImpl<const Decl *>::iterator
Argyrios Kyrtzidis442dd802012-07-02 19:19:01 +00004205 I = UpdatingVisibleDecls.begin(),
4206 E = UpdatingVisibleDecls.end(); I != E; ++I) {
4207 GetDeclRef(*I);
4208 }
4209
Argyrios Kyrtzidisacfbbd72013-08-07 21:17:33 +00004210 // Make sure all decls associated with an identifier are registered for
4211 // serialization.
4212 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
4213 IDEnd = PP.getIdentifierTable().end();
4214 ID != IDEnd; ++ID) {
4215 const IdentifierInfo *II = ID->second;
4216 if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) {
4217 for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II),
4218 DEnd = SemaRef.IdResolver.end();
4219 D != DEnd; ++D) {
4220 GetDeclRef(*D);
4221 }
4222 }
4223 }
4224
Douglas Gregor5204bde2011-08-02 16:26:37 +00004225 // Form the record of special types.
4226 RecordData SpecialTypes;
Douglas Gregor5204bde2011-08-02 16:26:37 +00004227 AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes);
Douglas Gregor5204bde2011-08-02 16:26:37 +00004228 AddTypeRef(Context.getFILEType(), SpecialTypes);
4229 AddTypeRef(Context.getjmp_bufType(), SpecialTypes);
4230 AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes);
4231 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
4232 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
Douglas Gregor5204bde2011-08-02 16:26:37 +00004233 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
Rafael Espindola6cfa82b2011-11-13 21:51:09 +00004234 AddTypeRef(Context.getucontext_tType(), SpecialTypes);
Douglas Gregora28bcdd2011-12-01 02:07:58 +00004235
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004236 if (Chain) {
4237 // Write the mapping information describing our module dependencies and how
4238 // each of those modules were mapped into our own offset/ID space, so that
4239 // the reader can build the appropriate mapping to its own offset/ID space.
4240 // The map consists solely of a blob with the following format:
4241 // *(module-name-len:i16 module-name:len*i8
4242 // source-location-offset:i32
4243 // identifier-id:i32
4244 // preprocessed-entity-id:i32
4245 // macro-definition-id:i32
Douglas Gregor253eefe2011-12-01 00:59:36 +00004246 // submodule-id:i32
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004247 // selector-id:i32
4248 // declaration-id:i32
4249 // c++-base-specifiers-id:i32
4250 // type-id:i32)
4251 //
4252 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
4253 Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
4254 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4255 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev);
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004256 SmallString<2048> Buffer;
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004257 {
4258 llvm::raw_svector_ostream Out(Buffer);
4259 for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(),
Douglas Gregor24bb9232011-12-02 18:58:38 +00004260 MEnd = Chain->ModuleMgr.end();
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004261 M != MEnd; ++M) {
Justin Bognere1c147c2014-03-28 22:03:19 +00004262 using namespace llvm::support;
4263 endian::Writer<little> LE(Out);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004264 StringRef FileName = (*M)->FileName;
Justin Bognere1c147c2014-03-28 22:03:19 +00004265 LE.write<uint16_t>(FileName.size());
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004266 Out.write(FileName.data(), FileName.size());
Justin Bognere1c147c2014-03-28 22:03:19 +00004267 LE.write<uint32_t>((*M)->SLocEntryBaseOffset);
4268 LE.write<uint32_t>((*M)->BaseIdentifierID);
4269 LE.write<uint32_t>((*M)->BaseMacroID);
4270 LE.write<uint32_t>((*M)->BasePreprocessedEntityID);
4271 LE.write<uint32_t>((*M)->BaseSubmoduleID);
4272 LE.write<uint32_t>((*M)->BaseSelectorID);
4273 LE.write<uint32_t>((*M)->BaseDeclID);
4274 LE.write<uint32_t>((*M)->BaseTypeIndex);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004275 }
4276 }
4277 Record.clear();
4278 Record.push_back(MODULE_OFFSET_MAP);
4279 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
4280 Buffer.data(), Buffer.size());
4281 }
Richard Smithb9eab6d2014-03-20 19:44:17 +00004282
Richard Smithb9eab6d2014-03-20 19:44:17 +00004283 RecordData DeclUpdatesOffsetsRecord;
4284
Richard Smith59442b42014-03-20 20:07:19 +00004285 // Keep writing types, declarations, and declaration update records
4286 // until we've emitted all of them.
Richard Smithb9eab6d2014-03-20 19:44:17 +00004287 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
4288 WriteDeclsBlockAbbrevs();
4289 for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(),
4290 E = DeclsToRewrite.end();
4291 I != E; ++I)
4292 DeclTypesToEmit.push(const_cast<Decl*>(*I));
Richard Smith59442b42014-03-20 20:07:19 +00004293 do {
4294 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord);
4295 while (!DeclTypesToEmit.empty()) {
4296 DeclOrType DOT = DeclTypesToEmit.front();
4297 DeclTypesToEmit.pop();
4298 if (DOT.isType())
4299 WriteType(DOT.getType());
4300 else
4301 WriteDecl(Context, DOT.getDecl());
4302 }
4303 } while (!DeclUpdates.empty());
Richard Smithb9eab6d2014-03-20 19:44:17 +00004304 Stream.ExitBlock();
4305
Richard Smithb9eab6d2014-03-20 19:44:17 +00004306 DoneWritingDeclsAndTypes = true;
4307
4308 // These things can only be done once we've written out decls and types.
4309 WriteTypeDeclOffsets();
Richard Smith5652c0f2014-03-21 01:48:23 +00004310 if (!DeclUpdatesOffsetsRecord.empty())
4311 Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord);
Richard Smithb9eab6d2014-03-20 19:44:17 +00004312 WriteCXXBaseSpecifiersOffsets();
4313 WriteFileDeclIDsMap();
4314 WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot);
4315
4316 WriteComments();
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +00004317 WritePreprocessor(PP, isModule);
Douglas Gregor09b69892011-02-10 17:09:37 +00004318 WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot);
Sebastian Redla19a67f2010-08-03 21:58:15 +00004319 WriteSelectors(SemaRef);
Fariborz Jahanianc51609a2010-07-23 19:11:11 +00004320 WriteReferencedSelectorsPool(SemaRef);
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +00004321 WriteIdentifierTable(PP, SemaRef.IdResolver, isModule);
Peter Collingbourne5df20e02011-02-15 19:46:30 +00004322 WriteFPPragmaOptions(SemaRef.getFPOptions());
4323 WriteOpenCLExtensions(SemaRef);
Argyrios Kyrtzidis0f06b982013-03-27 17:17:23 +00004324 WritePragmaDiagnosticMappings(Context.getDiagnostics(), isModule);
Douglas Gregor652d82a2009-04-18 05:55:16 +00004325
Douglas Gregora89c5ac2011-12-06 01:10:29 +00004326 // If we're emitting a module, write out the submodule information.
4327 if (WritingModule)
4328 WriteSubmodules(WritingModule);
4329
Douglas Gregor5204bde2011-08-02 16:26:37 +00004330 Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes);
4331
Douglas Gregord4df8652009-04-22 22:02:47 +00004332 // Write the record containing external, unnamed definitions.
Ben Langmuir332aafe2014-01-31 01:06:56 +00004333 if (!EagerlyDeserializedDecls.empty())
4334 Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls);
Douglas Gregord4df8652009-04-22 22:02:47 +00004335
4336 // Write the record containing tentative definitions.
4337 if (!TentativeDefinitions.empty())
Sebastian Redl539c5062010-08-18 23:57:32 +00004338 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
Douglas Gregoracfc76c2009-04-22 22:18:58 +00004339
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00004340 // Write the record containing unused file scoped decls.
4341 if (!UnusedFileScopedDecls.empty())
Sebastian Redl539c5062010-08-18 23:57:32 +00004342 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
Kovarththanan Rajaratnama9c81a82010-03-14 07:06:50 +00004343
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +00004344 // Write the record containing weak undeclared identifiers.
4345 if (!WeakUndeclaredIdentifiers.empty())
Sebastian Redl539c5062010-08-18 23:57:32 +00004346 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +00004347 WeakUndeclaredIdentifiers);
4348
Richard Smith78165b52013-01-10 23:43:47 +00004349 // Write the record containing locally-scoped extern "C" definitions.
4350 if (!LocallyScopedExternCDecls.empty())
4351 Stream.EmitRecord(LOCALLY_SCOPED_EXTERN_C_DECLS,
4352 LocallyScopedExternCDecls);
Douglas Gregor61cac2b2009-04-27 20:06:05 +00004353
4354 // Write the record containing ext_vector type names.
4355 if (!ExtVectorDecls.empty())
Sebastian Redl539c5062010-08-18 23:57:32 +00004356 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
Mike Stump11289f42009-09-09 15:08:12 +00004357
Argyrios Kyrtzidisaf2eac22010-07-06 15:37:04 +00004358 // Write the record containing VTable uses information.
4359 if (!VTableUses.empty())
Sebastian Redl539c5062010-08-18 23:57:32 +00004360 Stream.EmitRecord(VTABLE_USES, VTableUses);
Argyrios Kyrtzidisaf2eac22010-07-06 15:37:04 +00004361
4362 // Write the record containing dynamic classes declarations.
4363 if (!DynamicClasses.empty())
Sebastian Redl539c5062010-08-18 23:57:32 +00004364 Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses);
Argyrios Kyrtzidisaf2eac22010-07-06 15:37:04 +00004365
Argyrios Kyrtzidis7f76d112010-08-05 09:48:16 +00004366 // Write the record containing pending implicit instantiations.
Chandler Carruth54080172010-08-25 08:44:16 +00004367 if (!PendingInstantiations.empty())
4368 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
Argyrios Kyrtzidis7f76d112010-08-05 09:48:16 +00004369
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00004370 // Write the record containing declaration references of Sema.
4371 if (!SemaDeclRefs.empty())
Sebastian Redl539c5062010-08-18 23:57:32 +00004372 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
Argyrios Kyrtzidis2d688102010-08-02 07:14:54 +00004373
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00004374 // Write the record containing CUDA-specific declaration references.
4375 if (!CUDASpecialDeclRefs.empty())
4376 Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs);
Alexis Hunt27a761d2011-05-04 23:29:54 +00004377
4378 // Write the delegating constructors.
4379 if (!DelegatingCtorDecls.empty())
4380 Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls);
Peter Collingbourne9e2c81f2011-02-09 21:04:32 +00004381
Douglas Gregorc2fa1692011-06-28 16:20:02 +00004382 // Write the known namespaces.
4383 if (!KnownNamespaces.empty())
4384 Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces);
Nick Lewycky8334af82013-01-26 00:35:08 +00004385
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00004386 // Write the undefined internal functions and variables, and inline functions.
4387 if (!UndefinedButUsed.empty())
4388 Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed);
Douglas Gregorc2fa1692011-06-28 16:20:02 +00004389
Douglas Gregor851443c2011-08-12 01:39:19 +00004390 // Write the visible updates to DeclContexts.
4391 for (llvm::SmallPtrSet<const DeclContext *, 16>::iterator
4392 I = UpdatedDeclContexts.begin(),
4393 E = UpdatedDeclContexts.end();
4394 I != E; ++I)
4395 WriteDeclContextVisibleUpdate(*I);
4396
Douglas Gregor959bb062011-12-03 01:15:29 +00004397 if (!WritingModule) {
4398 // Write the submodules that were imported, if any.
Aaron Ballman4f45b712014-03-21 15:22:56 +00004399 struct ModuleInfo {
4400 uint64_t ID;
4401 Module *M;
4402 ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {}
4403 };
Richard Smith56be7542014-03-21 00:33:59 +00004404 llvm::SmallVector<ModuleInfo, 64> Imports;
Aaron Ballmanbbc31212014-03-14 20:59:21 +00004405 for (const auto *I : Context.local_imports()) {
Douglas Gregor959bb062011-12-03 01:15:29 +00004406 assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end());
Aaron Ballman4f45b712014-03-21 15:22:56 +00004407 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
4408 I->getImportedModule()));
Douglas Gregor959bb062011-12-03 01:15:29 +00004409 }
Richard Smith56be7542014-03-21 00:33:59 +00004410
4411 if (!Imports.empty()) {
4412 auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) {
4413 return A.ID < B.ID;
4414 };
4415
4416 // Sort and deduplicate module IDs.
4417 std::sort(Imports.begin(), Imports.end(), Cmp);
4418 Imports.erase(std::unique(Imports.begin(), Imports.end(), Cmp),
4419 Imports.end());
4420
4421 RecordData ImportedModules;
4422 for (const auto &Import : Imports) {
4423 ImportedModules.push_back(Import.ID);
4424 // FIXME: If the module has macros imported then later has declarations
4425 // imported, this location won't be the right one as a location for the
4426 // declaration imports.
4427 AddSourceLocation(Import.M->MacroVisibilityLoc, ImportedModules);
4428 }
4429
Douglas Gregor959bb062011-12-03 01:15:29 +00004430 Stream.EmitRecord(IMPORTED_MODULES, ImportedModules);
4431 }
Douglas Gregor0a839132011-12-03 00:59:55 +00004432 }
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00004433
Douglas Gregor851443c2011-08-12 01:39:19 +00004434 WriteDeclReplacementsBlock();
Douglas Gregor358cd442012-01-15 16:58:34 +00004435 WriteRedeclarations();
Douglas Gregor6168bd22013-02-18 15:53:43 +00004436 WriteMergedDecls();
Douglas Gregor404cdde2012-01-27 01:47:08 +00004437 WriteObjCCategories();
Richard Smithe40f2ba2013-08-07 21:41:30 +00004438 WriteLateParsedTemplates(SemaRef);
4439
Douglas Gregor08f01292009-04-17 22:13:46 +00004440 // Some simple statistics
Douglas Gregor652d82a2009-04-18 05:55:16 +00004441 Record.clear();
Douglas Gregor08f01292009-04-17 22:13:46 +00004442 Record.push_back(NumStatements);
Douglas Gregorc3366a52009-04-21 23:56:24 +00004443 Record.push_back(NumMacros);
Douglas Gregora57c3ab2009-04-22 22:34:57 +00004444 Record.push_back(NumLexicalDeclContexts);
4445 Record.push_back(NumVisibleDeclContexts);
Sebastian Redl539c5062010-08-18 23:57:32 +00004446 Stream.EmitRecord(STATISTICS, Record);
Douglas Gregor8f45df52009-04-16 22:23:12 +00004447 Stream.ExitBlock();
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004448}
4449
Richard Smithb9eab6d2014-03-20 19:44:17 +00004450void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00004451 if (DeclUpdates.empty())
4452 return;
4453
Richard Smith59442b42014-03-20 20:07:19 +00004454 DeclUpdateMap LocalUpdates;
4455 LocalUpdates.swap(DeclUpdates);
4456
Richard Smith6ef42932014-03-20 21:02:00 +00004457 for (auto &DeclUpdate : LocalUpdates) {
4458 const Decl *D = DeclUpdate.first;
Argyrios Kyrtzidisb97a4022011-11-12 21:07:46 +00004459 if (isRewritten(D))
Argyrios Kyrtzidis3ba70b82010-10-24 17:26:46 +00004460 continue; // The decl will be written completely,no need to store updates.
4461
Richard Smith6ef42932014-03-20 21:02:00 +00004462 OffsetsRecord.push_back(GetDeclRef(D));
4463 OffsetsRecord.push_back(Stream.GetCurrentBitNo());
4464
Richard Smithd28ac5b2014-03-22 23:33:22 +00004465 bool HasUpdatedBody = false;
Richard Smith6ef42932014-03-20 21:02:00 +00004466 RecordData Record;
4467 for (auto &Update : DeclUpdate.second) {
4468 DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind();
4469
4470 Record.push_back(Kind);
4471 switch (Kind) {
4472 case UPD_CXX_ADDED_IMPLICIT_MEMBER:
4473 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
4474 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE:
4475 Record.push_back(GetDeclRef(Update.getDecl()));
4476 break;
4477
4478 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
4479 AddSourceLocation(Update.getLoc(), Record);
4480 break;
4481
Richard Smithd28ac5b2014-03-22 23:33:22 +00004482 case UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION:
4483 // An updated body is emitted last, so that the reader doesn't need
4484 // to skip over the lazy body to reach statements for other records.
4485 Record.pop_back();
4486 HasUpdatedBody = true;
4487 break;
4488
Richard Smith564417a2014-03-20 21:47:22 +00004489 case UPD_CXX_RESOLVED_EXCEPTION_SPEC:
4490 addExceptionSpec(
4491 *this,
4492 cast<FunctionDecl>(D)->getType()->castAs<FunctionProtoType>(),
4493 Record);
4494 break;
4495
Richard Smith6ef42932014-03-20 21:02:00 +00004496 case UPD_CXX_DEDUCED_RETURN_TYPE:
4497 Record.push_back(GetOrCreateTypeID(Update.getType()));
4498 break;
4499
4500 case UPD_DECL_MARKED_USED:
4501 break;
Richard Smith5652c0f2014-03-21 01:48:23 +00004502
4503 case UPD_MANGLING_NUMBER:
4504 case UPD_STATIC_LOCAL_NUMBER:
4505 Record.push_back(Update.getNumber());
4506 break;
Richard Smith6ef42932014-03-20 21:02:00 +00004507 }
4508 }
4509
Richard Smithd28ac5b2014-03-22 23:33:22 +00004510 if (HasUpdatedBody) {
4511 const FunctionDecl *Def = cast<FunctionDecl>(D);
4512 Record.push_back(UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION);
4513 Record.push_back(Def->isInlined());
4514 AddSourceLocation(Def->getInnerLocStart(), Record);
4515 AddFunctionDefinition(Def, Record);
4516 }
4517
Richard Smith6ef42932014-03-20 21:02:00 +00004518 Stream.EmitRecord(DECL_UPDATES, Record);
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00004519
Richard Smithb9eab6d2014-03-20 19:44:17 +00004520 // Flush any statements that were written as part of this update record.
4521 FlushStmts();
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00004522 }
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00004523}
4524
Argyrios Kyrtzidis97bfda92010-10-24 17:26:43 +00004525void ASTWriter::WriteDeclReplacementsBlock() {
Sebastian Redle7c1fe62010-08-13 00:28:03 +00004526 if (ReplacedDecls.empty())
4527 return;
4528
4529 RecordData Record;
Craig Topper2341c0d2013-07-04 03:08:24 +00004530 for (SmallVectorImpl<ReplacedDeclInfo>::iterator
4531 I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) {
Argyrios Kyrtzidis6fb60032011-10-31 07:20:15 +00004532 Record.push_back(I->ID);
4533 Record.push_back(I->Offset);
4534 Record.push_back(I->Loc);
Sebastian Redle7c1fe62010-08-13 00:28:03 +00004535 }
Sebastian Redl539c5062010-08-18 23:57:32 +00004536 Stream.EmitRecord(DECL_REPLACEMENTS, Record);
Sebastian Redle7c1fe62010-08-13 00:28:03 +00004537}
4538
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004539void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004540 Record.push_back(Loc.getRawEncoding());
4541}
4542
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004543void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) {
Chris Lattnerca025db2010-05-07 21:43:38 +00004544 AddSourceLocation(Range.getBegin(), Record);
4545 AddSourceLocation(Range.getEnd(), Record);
4546}
4547
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004548void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004549 Record.push_back(Value.getBitWidth());
Benjamin Kramer25f9ea62010-09-06 23:43:28 +00004550 const uint64_t *Words = Value.getRawData();
4551 Record.append(Words, Words + Value.getNumWords());
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004552}
4553
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004554void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) {
Douglas Gregor1daeb692009-04-13 18:14:40 +00004555 Record.push_back(Value.isUnsigned());
4556 AddAPInt(Value, Record);
4557}
4558
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004559void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) {
Douglas Gregore0a3a512009-04-14 21:55:33 +00004560 AddAPInt(Value.bitcastToAPInt(), Record);
4561}
4562
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004563void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) {
Douglas Gregor4621c6a2009-04-22 18:49:13 +00004564 Record.push_back(getIdentifierRef(II));
4565}
4566
Sebastian Redl539c5062010-08-18 23:57:32 +00004567IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
Douglas Gregor4621c6a2009-04-22 18:49:13 +00004568 if (II == 0)
4569 return 0;
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00004570
Sebastian Redl539c5062010-08-18 23:57:32 +00004571 IdentID &ID = IdentifierIDs[II];
Douglas Gregor3ed42cb2009-04-11 00:14:32 +00004572 if (ID == 0)
Sebastian Redlff4a2952010-07-23 23:49:55 +00004573 ID = NextIdentID++;
Douglas Gregor4621c6a2009-04-22 18:49:13 +00004574 return ID;
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004575}
4576
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00004577MacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) {
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00004578 // Don't emit builtin macros like __LINE__ to the AST file unless they
4579 // have been redefined by the header (in which case they are not
4580 // isBuiltinMacro).
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00004581 if (MI == 0 || MI->isBuiltinMacro())
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00004582 return 0;
4583
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00004584 MacroID &ID = MacroIDs[MI];
4585 if (ID == 0) {
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00004586 ID = NextMacroID++;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00004587 MacroInfoToEmitData Info = { Name, MI, ID };
4588 MacroInfosToEmit.push_back(Info);
4589 }
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00004590 return ID;
4591}
4592
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00004593MacroID ASTWriter::getMacroID(MacroInfo *MI) {
4594 if (MI == 0 || MI->isBuiltinMacro())
4595 return 0;
4596
4597 assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!");
4598 return MacroIDs[MI];
4599}
4600
4601uint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) {
4602 assert(IdentMacroDirectivesOffsetMap[Name] && "not set!");
4603 return IdentMacroDirectivesOffsetMap[Name];
4604}
4605
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004606void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) {
Sebastian Redl834bb972010-08-04 17:20:04 +00004607 Record.push_back(getSelectorRef(SelRef));
4608}
4609
Sebastian Redl539c5062010-08-18 23:57:32 +00004610SelectorID ASTWriter::getSelectorRef(Selector Sel) {
Sebastian Redl834bb972010-08-04 17:20:04 +00004611 if (Sel.getAsOpaquePtr() == 0) {
4612 return 0;
Steve Naroff2ddea052009-04-23 10:39:46 +00004613 }
4614
Douglas Gregor8d7edce2013-02-08 21:30:59 +00004615 SelectorID SID = SelectorIDs[Sel];
Sebastian Redld95a56e2010-08-04 18:21:41 +00004616 if (SID == 0 && Chain) {
4617 // This might trigger a ReadSelector callback, which will set the ID for
4618 // this selector.
4619 Chain->LoadSelector(Sel);
Douglas Gregor8d7edce2013-02-08 21:30:59 +00004620 SID = SelectorIDs[Sel];
Sebastian Redld95a56e2010-08-04 18:21:41 +00004621 }
Steve Naroff2ddea052009-04-23 10:39:46 +00004622 if (SID == 0) {
Sebastian Redld95a56e2010-08-04 18:21:41 +00004623 SID = NextSelectorID++;
Douglas Gregor8d7edce2013-02-08 21:30:59 +00004624 SelectorIDs[Sel] = SID;
Steve Naroff2ddea052009-04-23 10:39:46 +00004625 }
Sebastian Redl834bb972010-08-04 17:20:04 +00004626 return SID;
Steve Naroff2ddea052009-04-23 10:39:46 +00004627}
4628
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004629void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) {
Chris Lattnercba86142010-05-10 00:25:06 +00004630 AddDeclRef(Temp->getDestructor(), Record);
4631}
4632
Douglas Gregord4c5ed02010-10-29 22:39:52 +00004633void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases,
4634 CXXBaseSpecifier const *BasesEnd,
4635 RecordDataImpl &Record) {
4636 assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded");
4637 CXXBaseSpecifiersToWrite.push_back(
4638 QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID,
4639 Bases, BasesEnd));
4640 Record.push_back(NextCXXBaseSpecifiersID++);
4641}
4642
Sebastian Redl55c0ad52010-08-18 23:56:21 +00004643void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +00004644 const TemplateArgumentLocInfo &Arg,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004645 RecordDataImpl &Record) {
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +00004646 switch (Kind) {
John McCall0ad16662009-10-29 08:12:44 +00004647 case TemplateArgument::Expression:
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +00004648 AddStmt(Arg.getAsExpr());
John McCall0ad16662009-10-29 08:12:44 +00004649 break;
4650 case TemplateArgument::Type:
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +00004651 AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record);
John McCall0ad16662009-10-29 08:12:44 +00004652 break;
Douglas Gregor9167f8b2009-11-11 01:00:40 +00004653 case TemplateArgument::Template:
Douglas Gregor9d802122011-03-02 17:09:35 +00004654 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
Argyrios Kyrtzidisddf5f212010-06-28 09:31:42 +00004655 AddSourceLocation(Arg.getTemplateNameLoc(), Record);
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004656 break;
4657 case TemplateArgument::TemplateExpansion:
Douglas Gregor9d802122011-03-02 17:09:35 +00004658 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004659 AddSourceLocation(Arg.getTemplateNameLoc(), Record);
Douglas Gregoreb29d182011-01-05 17:40:24 +00004660 AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record);
Douglas Gregor9167f8b2009-11-11 01:00:40 +00004661 break;
John McCall0ad16662009-10-29 08:12:44 +00004662 case TemplateArgument::Null:
4663 case TemplateArgument::Integral:
4664 case TemplateArgument::Declaration:
Eli Friedmanb826a002012-09-26 02:36:12 +00004665 case TemplateArgument::NullPtr:
John McCall0ad16662009-10-29 08:12:44 +00004666 case TemplateArgument::Pack:
Eli Friedmanb826a002012-09-26 02:36:12 +00004667 // FIXME: Is this right?
John McCall0ad16662009-10-29 08:12:44 +00004668 break;
4669 }
4670}
4671
Sebastian Redl55c0ad52010-08-18 23:56:21 +00004672void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004673 RecordDataImpl &Record) {
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +00004674 AddTemplateArgument(Arg.getArgument(), Record);
Argyrios Kyrtzidisddf5f212010-06-28 09:31:42 +00004675
4676 if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
4677 bool InfoHasSameExpr
4678 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
4679 Record.push_back(InfoHasSameExpr);
4680 if (InfoHasSameExpr)
4681 return; // Avoid storing the same expr twice.
4682 }
Argyrios Kyrtzidisae85e242010-06-22 09:54:59 +00004683 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(),
4684 Record);
4685}
4686
Douglas Gregora9d87bc2011-02-25 00:36:19 +00004687void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo,
4688 RecordDataImpl &Record) {
John McCallbcd03502009-12-07 02:54:59 +00004689 if (TInfo == 0) {
John McCall8f115c62009-10-16 21:56:05 +00004690 AddTypeRef(QualType(), Record);
4691 return;
4692 }
4693
Douglas Gregora9d87bc2011-02-25 00:36:19 +00004694 AddTypeLoc(TInfo->getTypeLoc(), Record);
4695}
4696
4697void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) {
4698 AddTypeRef(TL.getType(), Record);
4699
John McCall8f115c62009-10-16 21:56:05 +00004700 TypeLocWriter TLW(*this, Record);
Douglas Gregora9d87bc2011-02-25 00:36:19 +00004701 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
Kovarththanan Rajaratnama9c81a82010-03-14 07:06:50 +00004702 TLW.Visit(TL);
John McCall8f115c62009-10-16 21:56:05 +00004703}
4704
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004705void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) {
Argyrios Kyrtzidis9ab44ea2010-08-20 16:04:14 +00004706 Record.push_back(GetOrCreateTypeID(T));
4707}
4708
Douglas Gregoreda8e122011-08-09 15:13:55 +00004709TypeID ASTWriter::GetOrCreateTypeID( QualType T) {
Richard Smith1fa5d642013-05-11 05:45:24 +00004710 assert(Context);
Douglas Gregoreda8e122011-08-09 15:13:55 +00004711 return MakeTypeID(*Context, T,
Argyrios Kyrtzidis082e4612010-08-20 16:04:20 +00004712 std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this));
4713}
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004714
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00004715TypeID ASTWriter::getTypeID(QualType T) const {
Richard Smith1fa5d642013-05-11 05:45:24 +00004716 assert(Context);
Douglas Gregoreda8e122011-08-09 15:13:55 +00004717 return MakeTypeID(*Context, T,
Argyrios Kyrtzidis082e4612010-08-20 16:04:20 +00004718 std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this));
Argyrios Kyrtzidise394f2c2010-08-20 16:04:09 +00004719}
4720
4721TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) {
4722 if (T.isNull())
4723 return TypeIdx();
4724 assert(!T.getLocalFastQualifiers());
4725
Argyrios Kyrtzidisa7fbbb02010-08-20 16:04:04 +00004726 TypeIdx &Idx = TypeIdxs[T];
Argyrios Kyrtzidisbb5c7eae2010-08-20 16:03:59 +00004727 if (Idx.getIndex() == 0) {
Argyrios Kyrtzidis442dd802012-07-02 19:19:01 +00004728 if (DoneWritingDeclsAndTypes) {
4729 assert(0 && "New type seen after serializing all the types to emit!");
4730 return TypeIdx();
4731 }
4732
Douglas Gregor1970d882009-04-26 03:49:13 +00004733 // We haven't seen this type before. Assign it a new ID and put it
John McCall8ccfcb52009-09-24 19:53:00 +00004734 // into the queue of types to emit.
Argyrios Kyrtzidisbb5c7eae2010-08-20 16:03:59 +00004735 Idx = TypeIdx(NextTypeID++);
Douglas Gregor12bfa382009-10-17 00:13:19 +00004736 DeclTypesToEmit.push(T);
Douglas Gregor1970d882009-04-26 03:49:13 +00004737 }
Argyrios Kyrtzidise394f2c2010-08-20 16:04:09 +00004738 return Idx;
4739}
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004740
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00004741TypeIdx ASTWriter::getTypeIdx(QualType T) const {
Argyrios Kyrtzidise394f2c2010-08-20 16:04:09 +00004742 if (T.isNull())
4743 return TypeIdx();
4744 assert(!T.getLocalFastQualifiers());
4745
Argyrios Kyrtzidis07347322010-08-20 16:04:27 +00004746 TypeIdxMap::const_iterator I = TypeIdxs.find(T);
4747 assert(I != TypeIdxs.end() && "Type not emitted!");
4748 return I->second;
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004749}
4750
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00004751void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) {
Sebastian Redl66c5eef2010-07-27 00:17:23 +00004752 Record.push_back(GetDeclRef(D));
4753}
4754
Sebastian Redl539c5062010-08-18 23:57:32 +00004755DeclID ASTWriter::GetDeclRef(const Decl *D) {
Douglas Gregor2fd3d402011-09-17 00:05:03 +00004756 assert(WritingAST && "Cannot request a declaration ID before AST writing");
4757
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004758 if (D == 0) {
Sebastian Redl66c5eef2010-07-27 00:17:23 +00004759 return 0;
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004760 }
Douglas Gregorb3163e52012-01-05 22:33:30 +00004761
4762 // If D comes from an AST file, its declaration ID is already known and
4763 // fixed.
4764 if (D->isFromASTFile())
4765 return D->getGlobalID();
4766
Douglas Gregor9b3932c2010-10-05 18:37:06 +00004767 assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer");
Sebastian Redl539c5062010-08-18 23:57:32 +00004768 DeclID &ID = DeclIDs[D];
Mike Stump11289f42009-09-09 15:08:12 +00004769 if (ID == 0) {
Argyrios Kyrtzidis442dd802012-07-02 19:19:01 +00004770 if (DoneWritingDeclsAndTypes) {
4771 assert(0 && "New decl seen after serializing all the decls to emit!");
4772 return 0;
4773 }
4774
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004775 // We haven't seen this declaration before. Give it a new ID and
4776 // enqueue it in the list of declarations to emit.
Sebastian Redlff4a2952010-07-23 23:49:55 +00004777 ID = NextDeclID++;
Douglas Gregor12bfa382009-10-17 00:13:19 +00004778 DeclTypesToEmit.push(const_cast<Decl *>(D));
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004779 }
4780
Sebastian Redl66c5eef2010-07-27 00:17:23 +00004781 return ID;
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004782}
4783
Sebastian Redl539c5062010-08-18 23:57:32 +00004784DeclID ASTWriter::getDeclID(const Decl *D) {
Douglas Gregore84a9da2009-04-20 20:36:09 +00004785 if (D == 0)
4786 return 0;
4787
Douglas Gregorb3163e52012-01-05 22:33:30 +00004788 // If D comes from an AST file, its declaration ID is already known and
4789 // fixed.
4790 if (D->isFromASTFile())
4791 return D->getGlobalID();
4792
Douglas Gregore84a9da2009-04-20 20:36:09 +00004793 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
4794 return DeclIDs[D];
4795}
4796
Argyrios Kyrtzidisdf53da82011-10-28 23:57:43 +00004797void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) {
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004798 assert(ID);
Argyrios Kyrtzidisdf53da82011-10-28 23:57:43 +00004799 assert(D);
4800
4801 SourceLocation Loc = D->getLocation();
4802 if (Loc.isInvalid())
4803 return;
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004804
4805 // We only keep track of the file-level declarations of each file.
4806 if (!D->getLexicalDeclContext()->isFileContext())
4807 return;
Argyrios Kyrtzidise1bc99e2012-02-24 19:45:46 +00004808 // FIXME: ParmVarDecls that are part of a function type of a parameter of
4809 // a function/objc method, should not have TU as lexical context.
Argyrios Kyrtzidisffe055a82012-02-24 01:12:38 +00004810 if (isa<ParmVarDecl>(D))
4811 return;
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004812
4813 SourceManager &SM = Context->getSourceManager();
Argyrios Kyrtzidisdf53da82011-10-28 23:57:43 +00004814 SourceLocation FileLoc = SM.getFileLoc(Loc);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004815 assert(SM.isLocalSourceLocation(FileLoc));
Argyrios Kyrtzidis7362e9b2011-10-28 23:57:47 +00004816 FileID FID;
4817 unsigned Offset;
Benjamin Kramer867ea1d2014-03-02 13:01:17 +00004818 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004819 if (FID.isInvalid())
4820 return;
Argyrios Kyrtzidis4db774a2012-10-02 21:09:17 +00004821 assert(SM.getSLocEntry(FID).isFile());
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004822
Argyrios Kyrtzidis4db774a2012-10-02 21:09:17 +00004823 DeclIDInFileInfo *&Info = FileDeclIDs[FID];
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004824 if (!Info)
4825 Info = new DeclIDInFileInfo();
4826
Argyrios Kyrtzidis7362e9b2011-10-28 23:57:47 +00004827 std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID);
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004828 LocDeclIDsTy &Decls = Info->DeclIDs;
4829
Argyrios Kyrtzidis7362e9b2011-10-28 23:57:47 +00004830 if (Decls.empty() || Decls.back().first <= Offset) {
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004831 Decls.push_back(LocDecl);
4832 return;
4833 }
4834
Benjamin Kramer45025c02013-08-24 13:22:59 +00004835 LocDeclIDsTy::iterator I =
4836 std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first());
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +00004837
4838 Decls.insert(I, LocDecl);
4839}
4840
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004841void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) {
Chris Lattner258172e2009-04-27 07:35:58 +00004842 // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc.
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004843 Record.push_back(Name.getNameKind());
4844 switch (Name.getNameKind()) {
4845 case DeclarationName::Identifier:
4846 AddIdentifierRef(Name.getAsIdentifierInfo(), Record);
4847 break;
4848
4849 case DeclarationName::ObjCZeroArgSelector:
4850 case DeclarationName::ObjCOneArgSelector:
4851 case DeclarationName::ObjCMultiArgSelector:
Steve Naroff2ddea052009-04-23 10:39:46 +00004852 AddSelectorRef(Name.getObjCSelector(), Record);
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004853 break;
4854
4855 case DeclarationName::CXXConstructorName:
4856 case DeclarationName::CXXDestructorName:
4857 case DeclarationName::CXXConversionFunctionName:
4858 AddTypeRef(Name.getCXXNameType(), Record);
4859 break;
4860
4861 case DeclarationName::CXXOperatorName:
4862 Record.push_back(Name.getCXXOverloadedOperator());
4863 break;
4864
Alexis Hunt3d221f22009-11-29 07:34:05 +00004865 case DeclarationName::CXXLiteralOperatorName:
4866 AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record);
4867 break;
4868
Douglas Gregoref84c4b2009-04-09 22:27:44 +00004869 case DeclarationName::CXXUsingDirective:
4870 // No extra data to emit
4871 break;
4872 }
4873}
Chris Lattnerca025db2010-05-07 21:43:38 +00004874
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +00004875void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004876 DeclarationName Name, RecordDataImpl &Record) {
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +00004877 switch (Name.getNameKind()) {
4878 case DeclarationName::CXXConstructorName:
4879 case DeclarationName::CXXDestructorName:
4880 case DeclarationName::CXXConversionFunctionName:
4881 AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record);
4882 break;
4883
4884 case DeclarationName::CXXOperatorName:
4885 AddSourceLocation(
4886 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc),
4887 Record);
4888 AddSourceLocation(
4889 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc),
4890 Record);
4891 break;
4892
4893 case DeclarationName::CXXLiteralOperatorName:
4894 AddSourceLocation(
4895 SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc),
4896 Record);
4897 break;
4898
4899 case DeclarationName::Identifier:
4900 case DeclarationName::ObjCZeroArgSelector:
4901 case DeclarationName::ObjCOneArgSelector:
4902 case DeclarationName::ObjCMultiArgSelector:
4903 case DeclarationName::CXXUsingDirective:
4904 break;
4905 }
4906}
4907
4908void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004909 RecordDataImpl &Record) {
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +00004910 AddDeclarationName(NameInfo.getName(), Record);
4911 AddSourceLocation(NameInfo.getLoc(), Record);
4912 AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record);
4913}
4914
4915void ASTWriter::AddQualifierInfo(const QualifierInfo &Info,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004916 RecordDataImpl &Record) {
Douglas Gregor14454802011-02-25 02:25:35 +00004917 AddNestedNameSpecifierLoc(Info.QualifierLoc, Record);
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +00004918 Record.push_back(Info.NumTemplParamLists);
4919 for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i)
4920 AddTemplateParameterList(Info.TemplParamLists[i], Record);
4921}
4922
Sebastian Redl55c0ad52010-08-18 23:56:21 +00004923void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00004924 RecordDataImpl &Record) {
Chris Lattnerca025db2010-05-07 21:43:38 +00004925 // Nested name specifiers usually aren't too long. I think that 8 would
Chris Lattner57540c52011-04-15 05:22:18 +00004926 // typically accommodate the vast majority.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004927 SmallVector<NestedNameSpecifier *, 8> NestedNames;
Chris Lattnerca025db2010-05-07 21:43:38 +00004928
4929 // Push each of the NNS's onto a stack for serialization in reverse order.
4930 while (NNS) {
4931 NestedNames.push_back(NNS);
4932 NNS = NNS->getPrefix();
4933 }
4934
4935 Record.push_back(NestedNames.size());
4936 while(!NestedNames.empty()) {
4937 NNS = NestedNames.pop_back_val();
4938 NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
4939 Record.push_back(Kind);
4940 switch (Kind) {
4941 case NestedNameSpecifier::Identifier:
4942 AddIdentifierRef(NNS->getAsIdentifier(), Record);
4943 break;
4944
4945 case NestedNameSpecifier::Namespace:
4946 AddDeclRef(NNS->getAsNamespace(), Record);
4947 break;
4948
Douglas Gregor7b26ff92011-02-24 02:36:08 +00004949 case NestedNameSpecifier::NamespaceAlias:
4950 AddDeclRef(NNS->getAsNamespaceAlias(), Record);
4951 break;
4952
Chris Lattnerca025db2010-05-07 21:43:38 +00004953 case NestedNameSpecifier::TypeSpec:
4954 case NestedNameSpecifier::TypeSpecWithTemplate:
4955 AddTypeRef(QualType(NNS->getAsType(), 0), Record);
4956 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
4957 break;
4958
4959 case NestedNameSpecifier::Global:
4960 // Don't need to write an associated value.
4961 break;
4962 }
4963 }
4964}
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00004965
Douglas Gregora9d87bc2011-02-25 00:36:19 +00004966void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
4967 RecordDataImpl &Record) {
4968 // Nested name specifiers usually aren't too long. I think that 8 would
Chris Lattner57540c52011-04-15 05:22:18 +00004969 // typically accommodate the vast majority.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004970 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
Douglas Gregora9d87bc2011-02-25 00:36:19 +00004971
4972 // Push each of the nested-name-specifiers's onto a stack for
4973 // serialization in reverse order.
4974 while (NNS) {
4975 NestedNames.push_back(NNS);
4976 NNS = NNS.getPrefix();
4977 }
4978
4979 Record.push_back(NestedNames.size());
4980 while(!NestedNames.empty()) {
4981 NNS = NestedNames.pop_back_val();
4982 NestedNameSpecifier::SpecifierKind Kind
4983 = NNS.getNestedNameSpecifier()->getKind();
4984 Record.push_back(Kind);
4985 switch (Kind) {
4986 case NestedNameSpecifier::Identifier:
4987 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record);
4988 AddSourceRange(NNS.getLocalSourceRange(), Record);
4989 break;
4990
4991 case NestedNameSpecifier::Namespace:
4992 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record);
4993 AddSourceRange(NNS.getLocalSourceRange(), Record);
4994 break;
4995
4996 case NestedNameSpecifier::NamespaceAlias:
4997 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record);
4998 AddSourceRange(NNS.getLocalSourceRange(), Record);
4999 break;
5000
5001 case NestedNameSpecifier::TypeSpec:
5002 case NestedNameSpecifier::TypeSpecWithTemplate:
5003 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
5004 AddTypeLoc(NNS.getTypeLoc(), Record);
5005 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
5006 break;
5007
5008 case NestedNameSpecifier::Global:
5009 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
5010 break;
5011 }
5012 }
5013}
5014
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005015void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005016 TemplateName::NameKind Kind = Name.getKind();
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005017 Record.push_back(Kind);
5018 switch (Kind) {
5019 case TemplateName::Template:
5020 AddDeclRef(Name.getAsTemplateDecl(), Record);
5021 break;
5022
5023 case TemplateName::OverloadedTemplate: {
5024 OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate();
5025 Record.push_back(OvT->size());
5026 for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end();
5027 I != E; ++I)
5028 AddDeclRef(*I, Record);
5029 break;
5030 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005031
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005032 case TemplateName::QualifiedTemplate: {
5033 QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName();
5034 AddNestedNameSpecifier(QualT->getQualifier(), Record);
5035 Record.push_back(QualT->hasTemplateKeyword());
5036 AddDeclRef(QualT->getTemplateDecl(), Record);
5037 break;
5038 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005039
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005040 case TemplateName::DependentTemplate: {
5041 DependentTemplateName *DepT = Name.getAsDependentTemplateName();
5042 AddNestedNameSpecifier(DepT->getQualifier(), Record);
5043 Record.push_back(DepT->isIdentifier());
5044 if (DepT->isIdentifier())
5045 AddIdentifierRef(DepT->getIdentifier(), Record);
5046 else
5047 Record.push_back(DepT->getOperator());
5048 break;
5049 }
John McCalld9dfe3a2011-06-30 08:33:18 +00005050
5051 case TemplateName::SubstTemplateTemplateParm: {
5052 SubstTemplateTemplateParmStorage *subst
5053 = Name.getAsSubstTemplateTemplateParm();
5054 AddDeclRef(subst->getParameter(), Record);
5055 AddTemplateName(subst->getReplacement(), Record);
5056 break;
5057 }
Douglas Gregor5590be02011-01-15 06:45:20 +00005058
5059 case TemplateName::SubstTemplateTemplateParmPack: {
5060 SubstTemplateTemplateParmPackStorage *SubstPack
5061 = Name.getAsSubstTemplateTemplateParmPack();
5062 AddDeclRef(SubstPack->getParameterPack(), Record);
5063 AddTemplateArgument(SubstPack->getArgumentPack(), Record);
5064 break;
5065 }
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005066 }
5067}
5068
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005069void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005070 RecordDataImpl &Record) {
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005071 Record.push_back(Arg.getKind());
5072 switch (Arg.getKind()) {
5073 case TemplateArgument::Null:
5074 break;
5075 case TemplateArgument::Type:
5076 AddTypeRef(Arg.getAsType(), Record);
5077 break;
5078 case TemplateArgument::Declaration:
5079 AddDeclRef(Arg.getAsDecl(), Record);
Eli Friedmanb826a002012-09-26 02:36:12 +00005080 Record.push_back(Arg.isDeclForReferenceParam());
5081 break;
5082 case TemplateArgument::NullPtr:
5083 AddTypeRef(Arg.getNullPtrType(), Record);
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005084 break;
5085 case TemplateArgument::Integral:
Benjamin Kramer6003ad52012-06-07 15:09:51 +00005086 AddAPSInt(Arg.getAsIntegral(), Record);
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005087 AddTypeRef(Arg.getIntegralType(), Record);
5088 break;
5089 case TemplateArgument::Template:
Douglas Gregore1d60df2011-01-14 23:41:42 +00005090 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
5091 break;
Douglas Gregore4ff4b52011-01-05 18:58:31 +00005092 case TemplateArgument::TemplateExpansion:
5093 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
David Blaikie05785d12013-02-20 22:23:23 +00005094 if (Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions())
Douglas Gregore1d60df2011-01-14 23:41:42 +00005095 Record.push_back(*NumExpansions + 1);
5096 else
5097 Record.push_back(0);
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00005098 break;
5099 case TemplateArgument::Expression:
5100 AddStmt(Arg.getAsExpr());
5101 break;
5102 case TemplateArgument::Pack:
5103 Record.push_back(Arg.pack_size());
5104 for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end();
5105 I != E; ++I)
5106 AddTemplateArgument(*I, Record);
5107 break;
5108 }
5109}
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00005110
5111void
Sebastian Redl55c0ad52010-08-18 23:56:21 +00005112ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005113 RecordDataImpl &Record) {
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00005114 assert(TemplateParams && "No TemplateParams!");
5115 AddSourceLocation(TemplateParams->getTemplateLoc(), Record);
5116 AddSourceLocation(TemplateParams->getLAngleLoc(), Record);
5117 AddSourceLocation(TemplateParams->getRAngleLoc(), Record);
5118 Record.push_back(TemplateParams->size());
5119 for (TemplateParameterList::const_iterator
5120 P = TemplateParams->begin(), PEnd = TemplateParams->end();
5121 P != PEnd; ++P)
5122 AddDeclRef(*P, Record);
5123}
5124
5125/// \brief Emit a template argument list.
5126void
Sebastian Redl55c0ad52010-08-18 23:56:21 +00005127ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005128 RecordDataImpl &Record) {
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00005129 assert(TemplateArgs && "No TemplateArgs!");
Douglas Gregor1ccc8412010-11-07 23:05:16 +00005130 Record.push_back(TemplateArgs->size());
5131 for (int i=0, e = TemplateArgs->size(); i != e; ++i)
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00005132 AddTemplateArgument(TemplateArgs->get(i), Record);
5133}
Argyrios Kyrtzidis2c2167a2010-07-02 11:55:32 +00005134
Enea Zaffanella6dbe1872013-08-10 07:24:53 +00005135void
5136ASTWriter::AddASTTemplateArgumentListInfo
5137(const ASTTemplateArgumentListInfo *ASTTemplArgList, RecordDataImpl &Record) {
5138 assert(ASTTemplArgList && "No ASTTemplArgList!");
5139 AddSourceLocation(ASTTemplArgList->LAngleLoc, Record);
5140 AddSourceLocation(ASTTemplArgList->RAngleLoc, Record);
5141 Record.push_back(ASTTemplArgList->NumTemplateArgs);
5142 const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs();
5143 for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i)
5144 AddTemplateArgumentLoc(TemplArgs[i], Record);
5145}
Argyrios Kyrtzidis2c2167a2010-07-02 11:55:32 +00005146
5147void
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00005148ASTWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record) {
Argyrios Kyrtzidis2c2167a2010-07-02 11:55:32 +00005149 Record.push_back(Set.size());
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00005150 for (ASTUnresolvedSet::const_iterator
Argyrios Kyrtzidis2c2167a2010-07-02 11:55:32 +00005151 I = Set.begin(), E = Set.end(); I != E; ++I) {
5152 AddDeclRef(I.getDecl(), Record);
5153 Record.push_back(I.getAccess());
5154 }
5155}
Argyrios Kyrtzidis3701fcd2010-07-02 23:30:27 +00005156
Sebastian Redl55c0ad52010-08-18 23:56:21 +00005157void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005158 RecordDataImpl &Record) {
Argyrios Kyrtzidis3701fcd2010-07-02 23:30:27 +00005159 Record.push_back(Base.isVirtual());
5160 Record.push_back(Base.isBaseOfClass());
5161 Record.push_back(Base.getAccessSpecifierAsWritten());
Sebastian Redl08905022011-02-05 19:23:19 +00005162 Record.push_back(Base.getInheritConstructors());
Nick Lewycky19b9f952010-07-26 16:56:01 +00005163 AddTypeSourceInfo(Base.getTypeSourceInfo(), Record);
Argyrios Kyrtzidis3701fcd2010-07-02 23:30:27 +00005164 AddSourceRange(Base.getSourceRange(), Record);
Douglas Gregor752a5952011-01-03 22:36:02 +00005165 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc()
5166 : SourceLocation(),
5167 Record);
Argyrios Kyrtzidis3701fcd2010-07-02 23:30:27 +00005168}
Sebastian Redl85b2a6a2010-07-14 23:45:08 +00005169
Douglas Gregord4c5ed02010-10-29 22:39:52 +00005170void ASTWriter::FlushCXXBaseSpecifiers() {
5171 RecordData Record;
5172 for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) {
5173 Record.clear();
5174
5175 // Record the offset of this base-specifier set.
Douglas Gregorc27b2872011-08-04 00:01:48 +00005176 unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1;
Douglas Gregord4c5ed02010-10-29 22:39:52 +00005177 if (Index == CXXBaseSpecifiersOffsets.size())
5178 CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo());
5179 else {
5180 if (Index > CXXBaseSpecifiersOffsets.size())
5181 CXXBaseSpecifiersOffsets.resize(Index + 1);
5182 CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo();
5183 }
5184
5185 const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases,
5186 *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd;
5187 Record.push_back(BEnd - B);
5188 for (; B != BEnd; ++B)
5189 AddCXXBaseSpecifier(*B, Record);
5190 Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record);
Douglas Gregord5853042010-10-30 04:28:16 +00005191
5192 // Flush any expressions that were written as part of the base specifiers.
5193 FlushStmts();
Douglas Gregord4c5ed02010-10-29 22:39:52 +00005194 }
5195
5196 CXXBaseSpecifiersToWrite.clear();
5197}
5198
Alexis Hunt1d792652011-01-08 20:30:50 +00005199void ASTWriter::AddCXXCtorInitializers(
5200 const CXXCtorInitializer * const *CtorInitializers,
5201 unsigned NumCtorInitializers,
5202 RecordDataImpl &Record) {
5203 Record.push_back(NumCtorInitializers);
5204 for (unsigned i=0; i != NumCtorInitializers; ++i) {
5205 const CXXCtorInitializer *Init = CtorInitializers[i];
Argyrios Kyrtzidis5b6a03f2010-08-09 10:54:12 +00005206
Argyrios Kyrtzidis5b6a03f2010-08-09 10:54:12 +00005207 if (Init->isBaseInitializer()) {
Alexis Hunt37a477f2011-05-04 01:19:08 +00005208 Record.push_back(CTOR_INITIALIZER_BASE);
Douglas Gregord73f3dd2011-11-01 01:16:03 +00005209 AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
Argyrios Kyrtzidis5b6a03f2010-08-09 10:54:12 +00005210 Record.push_back(Init->isBaseVirtual());
Alexis Hunt37a477f2011-05-04 01:19:08 +00005211 } else if (Init->isDelegatingInitializer()) {
5212 Record.push_back(CTOR_INITIALIZER_DELEGATING);
Douglas Gregord73f3dd2011-11-01 01:16:03 +00005213 AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
Alexis Hunt37a477f2011-05-04 01:19:08 +00005214 } else if (Init->isMemberInitializer()){
5215 Record.push_back(CTOR_INITIALIZER_MEMBER);
5216 AddDeclRef(Init->getMember(), Record);
Argyrios Kyrtzidis5b6a03f2010-08-09 10:54:12 +00005217 } else {
Alexis Hunt37a477f2011-05-04 01:19:08 +00005218 Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
5219 AddDeclRef(Init->getIndirectMember(), Record);
Argyrios Kyrtzidis5b6a03f2010-08-09 10:54:12 +00005220 }
Francois Pichetd583da02010-12-04 09:14:42 +00005221
Argyrios Kyrtzidis5b6a03f2010-08-09 10:54:12 +00005222 AddSourceLocation(Init->getMemberLocation(), Record);
5223 AddStmt(Init->getInit());
Argyrios Kyrtzidis5b6a03f2010-08-09 10:54:12 +00005224 AddSourceLocation(Init->getLParenLoc(), Record);
5225 AddSourceLocation(Init->getRParenLoc(), Record);
5226 Record.push_back(Init->isWritten());
5227 if (Init->isWritten()) {
5228 Record.push_back(Init->getSourceOrder());
5229 } else {
5230 Record.push_back(Init->getNumArrayIndices());
5231 for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i)
5232 AddDeclRef(Init->getArrayIndex(i), Record);
5233 }
5234 }
5235}
5236
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005237void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) {
5238 assert(D->DefinitionData);
5239 struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData;
Douglas Gregor99ae8062012-02-14 17:54:36 +00005240 Record.push_back(Data.IsLambda);
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005241 Record.push_back(Data.UserDeclaredConstructor);
Richard Smith328aae52012-11-30 05:11:39 +00005242 Record.push_back(Data.UserDeclaredSpecialMembers);
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005243 Record.push_back(Data.Aggregate);
5244 Record.push_back(Data.PlainOldData);
5245 Record.push_back(Data.Empty);
5246 Record.push_back(Data.Polymorphic);
5247 Record.push_back(Data.Abstract);
Chandler Carruth583edf82011-04-30 10:07:30 +00005248 Record.push_back(Data.IsStandardLayout);
Chandler Carruthb1963742011-04-30 09:17:45 +00005249 Record.push_back(Data.HasNoNonEmptyBases);
5250 Record.push_back(Data.HasPrivateFields);
5251 Record.push_back(Data.HasProtectedFields);
5252 Record.push_back(Data.HasPublicFields);
Douglas Gregor61226d32011-05-13 01:05:07 +00005253 Record.push_back(Data.HasMutableFields);
Richard Smithab44d5b2013-12-10 08:25:00 +00005254 Record.push_back(Data.HasVariantMembers);
Richard Smith561fb152012-02-25 07:33:38 +00005255 Record.push_back(Data.HasOnlyCMembers);
Richard Smithe2648ba2012-05-07 01:07:30 +00005256 Record.push_back(Data.HasInClassInitializer);
Richard Smith593f9932012-12-08 02:01:17 +00005257 Record.push_back(Data.HasUninitializedReferenceMember);
Richard Smith6b02d462012-12-08 08:32:28 +00005258 Record.push_back(Data.NeedOverloadResolutionForMoveConstructor);
5259 Record.push_back(Data.NeedOverloadResolutionForMoveAssignment);
5260 Record.push_back(Data.NeedOverloadResolutionForDestructor);
5261 Record.push_back(Data.DefaultedMoveConstructorIsDeleted);
5262 Record.push_back(Data.DefaultedMoveAssignmentIsDeleted);
5263 Record.push_back(Data.DefaultedDestructorIsDeleted);
Richard Smith328aae52012-11-30 05:11:39 +00005264 Record.push_back(Data.HasTrivialSpecialMembers);
Richard Smithb45a6f72014-04-17 20:33:01 +00005265 Record.push_back(Data.DeclaredNonTrivialSpecialMembers);
Richard Smith328aae52012-11-30 05:11:39 +00005266 Record.push_back(Data.HasIrrelevantDestructor);
Richard Smith111af8d2011-08-10 18:11:37 +00005267 Record.push_back(Data.HasConstexprNonCopyMoveConstructor);
Richard Smith561fb152012-02-25 07:33:38 +00005268 Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr);
Richard Smith561fb152012-02-25 07:33:38 +00005269 Record.push_back(Data.HasConstexprDefaultConstructor);
Chandler Carruthe71d0622011-04-24 02:49:34 +00005270 Record.push_back(Data.HasNonLiteralTypeFieldsOrBases);
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005271 Record.push_back(Data.ComputedVisibleConversions);
Alexis Huntea6f0322011-05-11 22:34:38 +00005272 Record.push_back(Data.UserProvidedDefaultConstructor);
Richard Smith328aae52012-11-30 05:11:39 +00005273 Record.push_back(Data.DeclaredSpecialMembers);
Richard Smith1c33fe82012-11-28 06:23:12 +00005274 Record.push_back(Data.ImplicitCopyConstructorHasConstParam);
5275 Record.push_back(Data.ImplicitCopyAssignmentHasConstParam);
5276 Record.push_back(Data.HasDeclaredCopyConstructorWithConstParam);
5277 Record.push_back(Data.HasDeclaredCopyAssignmentWithConstParam);
Richard Smith561fb152012-02-25 07:33:38 +00005278 // IsLambda bit is already saved.
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005279
5280 Record.push_back(Data.NumBases);
Douglas Gregord4c5ed02010-10-29 22:39:52 +00005281 if (Data.NumBases > 0)
5282 AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases,
5283 Record);
5284
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005285 // FIXME: Make VBases lazily computed when needed to avoid storing them.
5286 Record.push_back(Data.NumVBases);
Douglas Gregord4c5ed02010-10-29 22:39:52 +00005287 if (Data.NumVBases > 0)
5288 AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases,
5289 Record);
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005290
Richard Smitha4ba74c2013-08-30 04:46:40 +00005291 AddUnresolvedSet(Data.Conversions.get(*Context), Record);
5292 AddUnresolvedSet(Data.VisibleConversions.get(*Context), Record);
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005293 // Data.Definition is the owning decl, no need to write it.
Richard Smith68ad0e72013-06-26 02:41:25 +00005294 AddDeclRef(D->getFirstFriend(), Record);
Douglas Gregor99ae8062012-02-14 17:54:36 +00005295
5296 // Add lambda-specific data.
5297 if (Data.IsLambda) {
5298 CXXRecordDecl::LambdaDefinitionData &Lambda = D->getLambdaData();
Douglas Gregor680e9e02012-02-21 19:11:17 +00005299 Record.push_back(Lambda.Dependent);
Faisal Valic1a6dc42013-10-23 16:10:50 +00005300 Record.push_back(Lambda.IsGenericLambda);
5301 Record.push_back(Lambda.CaptureDefault);
Douglas Gregor99ae8062012-02-14 17:54:36 +00005302 Record.push_back(Lambda.NumCaptures);
5303 Record.push_back(Lambda.NumExplicitCaptures);
Douglas Gregor63798542012-02-20 19:44:39 +00005304 Record.push_back(Lambda.ManglingNumber);
Douglas Gregor7fcbd902012-02-21 00:37:24 +00005305 AddDeclRef(Lambda.ContextDecl, Record);
Eli Friedmand564afb2012-09-19 01:18:11 +00005306 AddTypeSourceInfo(Lambda.MethodTyInfo, Record);
Douglas Gregor99ae8062012-02-14 17:54:36 +00005307 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
5308 LambdaExpr::Capture &Capture = Lambda.Captures[I];
5309 AddSourceLocation(Capture.getLocation(), Record);
5310 Record.push_back(Capture.isImplicit());
Richard Smithba71c082013-05-16 06:20:58 +00005311 Record.push_back(Capture.getCaptureKind());
5312 switch (Capture.getCaptureKind()) {
5313 case LCK_This:
5314 break;
5315 case LCK_ByCopy:
Richard Smithbb13c9a2013-09-28 04:02:39 +00005316 case LCK_ByRef:
Richard Smithba71c082013-05-16 06:20:58 +00005317 VarDecl *Var =
5318 Capture.capturesVariable() ? Capture.getCapturedVar() : 0;
5319 AddDeclRef(Var, Record);
5320 AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc()
5321 : SourceLocation(),
5322 Record);
5323 break;
5324 }
Douglas Gregor99ae8062012-02-14 17:54:36 +00005325 }
5326 }
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +00005327}
5328
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00005329void ASTWriter::ReaderInitialized(ASTReader *Reader) {
Sebastian Redl07a89a82010-07-30 00:29:29 +00005330 assert(Reader && "Cannot remove chain");
Douglas Gregordf0c1512011-08-18 04:12:04 +00005331 assert((!Chain || Chain == Reader) && "Cannot replace chain");
Sebastian Redl07a89a82010-07-30 00:29:29 +00005332 assert(FirstDeclID == NextDeclID &&
5333 FirstTypeID == NextTypeID &&
5334 FirstIdentID == NextIdentID &&
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00005335 FirstMacroID == NextMacroID &&
Douglas Gregor253eefe2011-12-01 00:59:36 +00005336 FirstSubmoduleID == NextSubmoduleID &&
Sebastian Redld95a56e2010-08-04 18:21:41 +00005337 FirstSelectorID == NextSelectorID &&
Sebastian Redl07a89a82010-07-30 00:29:29 +00005338 "Setting chain after writing has started.");
Douglas Gregor925296b2011-07-19 16:10:42 +00005339
Sebastian Redl07a89a82010-07-30 00:29:29 +00005340 Chain = Reader;
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00005341
Douglas Gregordf0c1512011-08-18 04:12:04 +00005342 FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls();
5343 FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes();
5344 FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers();
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00005345 FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros();
Douglas Gregor253eefe2011-12-01 00:59:36 +00005346 FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules();
Douglas Gregordf0c1512011-08-18 04:12:04 +00005347 FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors();
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00005348 NextDeclID = FirstDeclID;
5349 NextTypeID = FirstTypeID;
5350 NextIdentID = FirstIdentID;
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00005351 NextMacroID = FirstMacroID;
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00005352 NextSelectorID = FirstSelectorID;
Douglas Gregor253eefe2011-12-01 00:59:36 +00005353 NextSubmoduleID = FirstSubmoduleID;
Sebastian Redl07a89a82010-07-30 00:29:29 +00005354}
5355
Sebastian Redl539c5062010-08-18 23:57:32 +00005356void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) {
Douglas Gregor8d7edce2013-02-08 21:30:59 +00005357 // Always keep the highest ID. See \p TypeRead() for more information.
5358 IdentID &StoredID = IdentifierIDs[II];
5359 if (ID > StoredID)
5360 StoredID = ID;
Sebastian Redlff4a2952010-07-23 23:49:55 +00005361}
5362
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00005363void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) {
Douglas Gregor8d7edce2013-02-08 21:30:59 +00005364 // Always keep the highest ID. See \p TypeRead() for more information.
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00005365 MacroID &StoredID = MacroIDs[MI];
Douglas Gregor8d7edce2013-02-08 21:30:59 +00005366 if (ID > StoredID)
5367 StoredID = ID;
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00005368}
5369
Argyrios Kyrtzidisbb5c7eae2010-08-20 16:03:59 +00005370void ASTWriter::TypeRead(TypeIdx Idx, QualType T) {
Douglas Gregor9b3932c2010-10-05 18:37:06 +00005371 // Always take the highest-numbered type index. This copes with an interesting
5372 // case for chained AST writing where we schedule writing the type and then,
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005373 // later, deserialize the type from another AST. In this case, we want to
Douglas Gregor9b3932c2010-10-05 18:37:06 +00005374 // keep the higher-numbered entry so that we can properly write it out to
5375 // the AST file.
5376 TypeIdx &StoredIdx = TypeIdxs[T];
5377 if (Idx.getIndex() >= StoredIdx.getIndex())
5378 StoredIdx = Idx;
Sebastian Redl85b2a6a2010-07-14 23:45:08 +00005379}
5380
Sebastian Redl539c5062010-08-18 23:57:32 +00005381void ASTWriter::SelectorRead(SelectorID ID, Selector S) {
Douglas Gregor8d7edce2013-02-08 21:30:59 +00005382 // Always keep the highest ID. See \p TypeRead() for more information.
5383 SelectorID &StoredID = SelectorIDs[S];
5384 if (ID > StoredID)
5385 StoredID = ID;
Sebastian Redl834bb972010-08-04 17:20:04 +00005386}
Douglas Gregor91096292010-10-02 19:29:26 +00005387
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00005388void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID,
Douglas Gregor91096292010-10-02 19:29:26 +00005389 MacroDefinition *MD) {
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +00005390 assert(MacroDefinitions.find(MD) == MacroDefinitions.end());
Douglas Gregor91096292010-10-02 19:29:26 +00005391 MacroDefinitions[MD] = ID;
5392}
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00005393
Douglas Gregore37a85a2011-12-02 17:30:13 +00005394void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) {
5395 assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end());
5396 SubmoduleIDs[Mod] = ID;
5397}
5398
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00005399void ASTWriter::CompletedTagDefinition(const TagDecl *D) {
John McCallf937c022011-10-07 06:10:15 +00005400 assert(D->isCompleteDefinition());
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005401 assert(!WritingAST && "Already writing the AST!");
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00005402 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
5403 // We are interested when a PCH decl is modified.
Douglas Gregorb3722e22011-09-09 23:01:35 +00005404 if (RD->isFromASTFile()) {
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00005405 // A forward reference was mutated into a definition. Rewrite it.
5406 // FIXME: This happens during template instantiation, should we
5407 // have created a new definition decl instead ?
Argyrios Kyrtzidis47299722010-10-28 07:38:45 +00005408 RewriteDecl(RD);
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00005409 }
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00005410 }
5411}
Douglas Gregorcb28f9d2012-10-09 23:05:51 +00005412
Argyrios Kyrtzidis01c2df42010-10-28 07:38:51 +00005413void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) {
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005414 assert(!WritingAST && "Already writing the AST!");
5415
Argyrios Kyrtzidis01c2df42010-10-28 07:38:51 +00005416 // TU and namespaces are handled elsewhere.
5417 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC))
5418 return;
5419
Douglas Gregorb3722e22011-09-09 23:01:35 +00005420 if (!(!D->isFromASTFile() && cast<Decl>(DC)->isFromASTFile()))
Argyrios Kyrtzidis01c2df42010-10-28 07:38:51 +00005421 return; // Not a source decl added to a DeclContext from PCH.
5422
Douglas Gregor9f782892013-01-21 15:25:38 +00005423 assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!");
Argyrios Kyrtzidis01c2df42010-10-28 07:38:51 +00005424 AddUpdatedDeclContext(DC);
Argyrios Kyrtzidis442dd802012-07-02 19:19:01 +00005425 UpdatingVisibleDecls.push_back(D);
Argyrios Kyrtzidis01c2df42010-10-28 07:38:51 +00005426}
Argyrios Kyrtzidise16a5302010-10-24 17:26:54 +00005427
5428void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) {
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005429 assert(!WritingAST && "Already writing the AST!");
Argyrios Kyrtzidise16a5302010-10-24 17:26:54 +00005430 assert(D->isImplicit());
Douglas Gregorb3722e22011-09-09 23:01:35 +00005431 if (!(!D->isFromASTFile() && RD->isFromASTFile()))
Argyrios Kyrtzidise16a5302010-10-24 17:26:54 +00005432 return; // Not a source member added to a class from PCH.
5433 if (!isa<CXXMethodDecl>(D))
5434 return; // We are interested in lazily declared implicit methods.
5435
5436 // A decl coming from PCH was modified.
John McCallf937c022011-10-07 06:10:15 +00005437 assert(RD->isCompleteDefinition());
Aaron Ballman4f45b712014-03-21 15:22:56 +00005438 DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D));
Argyrios Kyrtzidise16a5302010-10-24 17:26:54 +00005439}
Argyrios Kyrtzidis402dbbb2010-10-28 07:38:42 +00005440
5441void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
5442 const ClassTemplateSpecializationDecl *D) {
Argyrios Kyrtzidisef80a012010-10-28 07:38:47 +00005443 // The specializations set is kept in the canonical template.
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005444 assert(!WritingAST && "Already writing the AST!");
Argyrios Kyrtzidisef80a012010-10-28 07:38:47 +00005445 TD = TD->getCanonicalDecl();
Douglas Gregorb3722e22011-09-09 23:01:35 +00005446 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
Argyrios Kyrtzidis402dbbb2010-10-28 07:38:42 +00005447 return; // Not a source specialization added to a template from PCH.
5448
Aaron Ballman4f45b712014-03-21 15:22:56 +00005449 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION,
5450 D));
Argyrios Kyrtzidis402dbbb2010-10-28 07:38:42 +00005451}
Douglas Gregorf88e35b2010-11-30 06:16:57 +00005452
Larisse Voufo39a1e502013-08-06 01:03:05 +00005453void ASTWriter::AddedCXXTemplateSpecialization(
5454 const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) {
5455 // The specializations set is kept in the canonical template.
5456 assert(!WritingAST && "Already writing the AST!");
5457 TD = TD->getCanonicalDecl();
5458 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
5459 return; // Not a source specialization added to a template from PCH.
5460
Aaron Ballman4f45b712014-03-21 15:22:56 +00005461 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION,
5462 D));
Larisse Voufo39a1e502013-08-06 01:03:05 +00005463}
5464
Sebastian Redl9ab988f2011-04-14 14:07:59 +00005465void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
5466 const FunctionDecl *D) {
5467 // The specializations set is kept in the canonical template.
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005468 assert(!WritingAST && "Already writing the AST!");
Sebastian Redl9ab988f2011-04-14 14:07:59 +00005469 TD = TD->getCanonicalDecl();
Douglas Gregorb3722e22011-09-09 23:01:35 +00005470 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
Sebastian Redl9ab988f2011-04-14 14:07:59 +00005471 return; // Not a source specialization added to a template from PCH.
5472
Aaron Ballman4f45b712014-03-21 15:22:56 +00005473 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION,
5474 D));
Sebastian Redl9ab988f2011-04-14 14:07:59 +00005475}
5476
Richard Smith564417a2014-03-20 21:47:22 +00005477void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) {
5478 assert(!WritingAST && "Already writing the AST!");
5479 FD = FD->getCanonicalDecl();
5480 if (!FD->isFromASTFile())
5481 return; // Not a function declared in PCH and defined outside.
5482
5483 DeclUpdates[FD].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC);
5484}
5485
Richard Smith1fa5d642013-05-11 05:45:24 +00005486void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) {
5487 assert(!WritingAST && "Already writing the AST!");
5488 FD = FD->getCanonicalDecl();
5489 if (!FD->isFromASTFile())
5490 return; // Not a function declared in PCH and defined outside.
5491
Aaron Ballman4f45b712014-03-21 15:22:56 +00005492 DeclUpdates[FD].push_back(DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType));
Richard Smith1fa5d642013-05-11 05:45:24 +00005493}
5494
Sebastian Redlab238a72011-04-24 16:28:06 +00005495void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) {
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005496 assert(!WritingAST && "Already writing the AST!");
Douglas Gregorb3722e22011-09-09 23:01:35 +00005497 if (!D->isFromASTFile())
Sebastian Redlab238a72011-04-24 16:28:06 +00005498 return; // Declaration not imported from PCH.
5499
5500 // Implicit decl from a PCH was defined.
5501 // FIXME: Should implicit definition be a separate FunctionDecl?
5502 RewriteDecl(D);
5503}
5504
Richard Smithd28ac5b2014-03-22 23:33:22 +00005505void ASTWriter::FunctionDefinitionInstantiated(const FunctionDecl *D) {
5506 assert(!WritingAST && "Already writing the AST!");
5507 if (!D->isFromASTFile())
5508 return;
5509
5510 // Since the actual instantiation is delayed, this really means that we need
5511 // to update the instantiation location.
5512 DeclUpdates[D].push_back(
5513 DeclUpdate(UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION));
5514}
5515
Sebastian Redl2ac2c722011-04-29 08:19:30 +00005516void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) {
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005517 assert(!WritingAST && "Already writing the AST!");
Douglas Gregorb3722e22011-09-09 23:01:35 +00005518 if (!D->isFromASTFile())
Sebastian Redl2ac2c722011-04-29 08:19:30 +00005519 return;
5520
5521 // Since the actual instantiation is delayed, this really means that we need
5522 // to update the instantiation location.
Richard Smith6ef42932014-03-20 21:02:00 +00005523 DeclUpdates[D].push_back(
Aaron Ballman4f45b712014-03-21 15:22:56 +00005524 DeclUpdate(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER,
5525 D->getMemberSpecializationInfo()->getPointOfInstantiation()));
Sebastian Redl2ac2c722011-04-29 08:19:30 +00005526}
5527
Argyrios Kyrtzidis7d847c92011-09-01 00:58:55 +00005528void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
5529 const ObjCInterfaceDecl *IFD) {
Douglas Gregor2fd3d402011-09-17 00:05:03 +00005530 assert(!WritingAST && "Already writing the AST!");
Douglas Gregorb3722e22011-09-09 23:01:35 +00005531 if (!IFD->isFromASTFile())
Argyrios Kyrtzidis7d847c92011-09-01 00:58:55 +00005532 return; // Declaration not imported from PCH.
Douglas Gregor404cdde2012-01-27 01:47:08 +00005533
5534 assert(IFD->getDefinition() && "Category on a class without a definition?");
5535 ObjCClassesWithCategories.insert(
5536 const_cast<ObjCInterfaceDecl *>(IFD->getDefinition()));
Argyrios Kyrtzidis7d847c92011-09-01 00:58:55 +00005537}
Argyrios Kyrtzidisb97a4022011-11-12 21:07:46 +00005538
Argyrios Kyrtzidis0ca3a8b2011-11-12 21:07:52 +00005539
Argyrios Kyrtzidis846e61a2011-11-14 04:52:29 +00005540void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop,
5541 const ObjCPropertyDecl *OrigProp,
5542 const ObjCCategoryDecl *ClassExt) {
5543 const ObjCInterfaceDecl *D = ClassExt->getClassInterface();
5544 if (!D)
5545 return;
5546
5547 assert(!WritingAST && "Already writing the AST!");
5548 if (!D->isFromASTFile())
5549 return; // Declaration not imported from PCH.
5550
5551 RewriteDecl(D);
5552}
Eli Friedman276dd182013-09-05 00:02:25 +00005553
5554void ASTWriter::DeclarationMarkedUsed(const Decl *D) {
5555 assert(!WritingAST && "Already writing the AST!");
5556 if (!D->isFromASTFile())
5557 return;
5558
Aaron Ballman4f45b712014-03-21 15:22:56 +00005559 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_USED));
Eli Friedman276dd182013-09-05 00:02:25 +00005560}