ASTWriter.cpp revision 58a2cd8c0d52e710cbcc57a67eac7b51b0b831c4
121cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin//===--- ASTWriter.cpp - AST File Writer ----------------------------------===// 221cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin// 3319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin// The LLVM Compiler Infrastructure 48bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin// 58bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin// This file is distributed under the University of Illinois Open Source 6f315c0128b5f6317f910f6c54119fea97256254cZack Rusin// License. See LICENSE.TXT for details. 73bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer// 8ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger//===----------------------------------------------------------------------===// 9f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin// 10f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin// This file defines the ASTWriter class, which writes AST files. 11a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin// 12a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin//===----------------------------------------------------------------------===// 13a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin 1417076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/Serialization/ASTWriter.h" 15c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Serialization/ASTSerializationListener.h" 1617076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "ASTCommon.h" 17c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Sema/Sema.h" 18c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Sema/IdentifierResolver.h" 198adcad0c703a9d339b6630ceaba5f96981c524d9Zack Rusin#include "clang/AST/ASTContext.h" 20c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/AST/Decl.h" 21c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/AST/DeclContextInternals.h" 2217076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/AST/DeclTemplate.h" 2317076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/AST/DeclFriend.h" 242048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin#include "clang/AST/Expr.h" 2517076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/AST/ExprCXX.h" 2617076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/AST/Type.h" 27c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/AST/TypeLocVisitor.h" 2817076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/Serialization/ASTReader.h" 29c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Lex/MacroInfo.h" 3017076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/Lex/PreprocessingRecord.h" 31c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Lex/Preprocessor.h" 3217076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/Lex/HeaderSearch.h" 33c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Basic/FileManager.h" 3417076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin#include "clang/Basic/FileSystemStatCache.h" 35c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Basic/OnDiskHashTable.h" 36074e069910c7082620be4211fe5496365f828886Zack Rusin#include "clang/Basic/SourceManager.h" 37c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Basic/SourceManagerInternals.h" 38074e069910c7082620be4211fe5496365f828886Zack Rusin#include "clang/Basic/TargetInfo.h" 39c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "clang/Basic/Version.h" 40074e069910c7082620be4211fe5496365f828886Zack Rusin#include "clang/Basic/VersionTuple.h" 41c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "llvm/ADT/APFloat.h" 4259cf40059a7c451b1d1bc0c90f674e8e4baa5ab8Zack Rusin#include "llvm/ADT/APInt.h" 43c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "llvm/ADT/StringExtras.h" 44074e069910c7082620be4211fe5496365f828886Zack Rusin#include "llvm/Bitcode/BitstreamWriter.h" 45c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "llvm/Support/FileSystem.h" 46074e069910c7082620be4211fe5496365f828886Zack Rusin#include "llvm/Support/MemoryBuffer.h" 47c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include "llvm/Support/Path.h" 48074e069910c7082620be4211fe5496365f828886Zack Rusin#include <cstdio> 49c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin#include <string.h> 50074e069910c7082620be4211fe5496365f828886Zack Rusinusing namespace clang; 51c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusinusing namespace clang::serialization; 5217076d700c94402f82c22b2e1d99a1753e4a0834Zack Rusin 5321cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusintemplate <typename T, typename Allocator> 546be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack RusinT *data(std::vector<T, Allocator> &v) { 556be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin return v.empty() ? 0 : &v.front(); 563bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer} 576be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusintemplate <typename T, typename Allocator> 583bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzerconst T *data(const std::vector<T, Allocator> &v) { 593bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer return v.empty() ? 0 : &v.front(); 603bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer} 613bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer 623bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer//===----------------------------------------------------------------------===// 633bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer// Type serialization 643bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer//===----------------------------------------------------------------------===// 653bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer 663bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzernamespace { 676be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin class ASTTypeWriter { 686be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin ASTWriter &Writer; 691f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin ASTWriter::RecordDataImpl &Record; 701f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin 711f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin public: 72c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin /// \brief Type code that corresponds to the record generated. 732048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin TypeCode Code; 742048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin 752048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) 762048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { } 771f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin 781f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin void VisitArrayType(const ArrayType *T); 791f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin void VisitFunctionType(const FunctionType *T); 801f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin void VisitTagType(const TagType *T); 812048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin 822048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin#define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); 831f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin#define ABSTRACT_TYPE(Class, Base) 841f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin#include "clang/AST/TypeNodes.def" 851f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin }; 861f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin} 872048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin 88c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusinvoid ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { 89c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin assert(false && "Built-in types are never serialized"); 901f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin} 91c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin 921f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusinvoid ASTTypeWriter::VisitComplexType(const ComplexType *T) { 931f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Writer.AddTypeRef(T->getElementType(), Record); 941f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Code = TYPE_COMPLEX; 951f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin} 961f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin 97c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusinvoid ASTTypeWriter::VisitPointerType(const PointerType *T) { 98c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Writer.AddTypeRef(T->getPointeeType(), Record); 99c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Code = TYPE_POINTER; 100c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin} 1011f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin 102c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusinvoid ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { 1031f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Writer.AddTypeRef(T->getPointeeType(), Record); 1041f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Code = TYPE_BLOCK_POINTER; 1051f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin} 1061f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin 1071f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusinvoid ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { 108c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); 109c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Record.push_back(T->isSpelledAsLValue()); 110b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin Code = TYPE_LVALUE_REFERENCE; 1111f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin} 1122048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin 1132048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusinvoid ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { 114d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); 115d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Code = TYPE_RVALUE_REFERENCE; 116d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin} 117d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin 118d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusinvoid ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { 119fca8b2c3ae53695f8ff6e823cc316aab910490e5Zack Rusin Writer.AddTypeRef(T->getPointeeType(), Record); 120d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Writer.AddTypeRef(QualType(T->getClass(), 0), Record); 121d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Code = TYPE_MEMBER_POINTER; 122d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin} 123d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin 124d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusinvoid ASTTypeWriter::VisitArrayType(const ArrayType *T) { 125d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Writer.AddTypeRef(T->getElementType(), Record); 126d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Record.push_back(T->getSizeModifier()); // FIXME: stable values 127d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values 128d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin} 129d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin 130d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusinvoid ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { 131d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin VisitArrayType(T); 132a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddAPInt(T->getSize(), Record); 133a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Code = TYPE_CONSTANT_ARRAY; 134a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 135a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin 136a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 137a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin VisitArrayType(T); 138a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Code = TYPE_INCOMPLETE_ARRAY; 139a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 140a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin 141a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { 142a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin VisitArrayType(T); 143a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(T->getLBracketLoc(), Record); 144a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(T->getRBracketLoc(), Record); 145a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddStmt(T->getSizeExpr()); 146a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Code = TYPE_VARIABLE_ARRAY; 147a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 148a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin 149a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid ASTTypeWriter::VisitVectorType(const VectorType *T) { 150a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddTypeRef(T->getElementType(), Record); 151a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(T->getNumElements()); 15246feb7db71b05ec67a7c78f6bc608adec0734decVinson Lee Record.push_back(T->getVectorKind()); 15346feb7db71b05ec67a7c78f6bc608adec0734decVinson Lee Code = TYPE_VECTOR; 15446feb7db71b05ec67a7c78f6bc608adec0734decVinson Lee} 155a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin 15608cb1d0ce4765536f1cb6a9253a2245c31fb8ea9Vinson Leevoid ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { 157a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin VisitVectorType(T); 158a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Code = TYPE_EXT_VECTOR; 159a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 160a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin 161a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid ASTTypeWriter::VisitFunctionType(const FunctionType *T) { 162a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddTypeRef(T->getResultType(), Record); 163a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin FunctionType::ExtInfo C = T->getExtInfo(); 164a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(C.getNoReturn()); 165a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(C.getHasRegParm()); 166a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(C.getRegParm()); 167a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin // FIXME: need to stabilize encoding of calling convention... 168a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(C.getCC()); 169a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 170a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin 171a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 17221cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin VisitFunctionType(T); 17321cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin Code = TYPE_FUNCTION_NO_PROTO; 17421cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin} 17521cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin 17621cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusinvoid ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { 1776d629d4aa211d098fe9541d0b644cf67ee1d7019Jakob Bornecrantz VisitFunctionType(T); 1782bb2e6a6e3017d462be0ae9308955f37c5ee03c6Dave Airlie Record.push_back(T->getNumArgs()); 1796d629d4aa211d098fe9541d0b644cf67ee1d7019Jakob Bornecrantz for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I) 1801f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Writer.AddTypeRef(T->getArgType(I), Record); 181c7653a83330e5ea63ad3a566da15155e216c6cb4Zack Rusin Record.push_back(T->isVariadic()); 182a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(T->getTypeQuals()); 183a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(static_cast<unsigned>(T->getRefQualifier())); 184a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(T->getExceptionSpecType()); 185a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin if (T->getExceptionSpecType() == EST_Dynamic) { 186a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(T->getNumExceptions()); 187626553f327394b835cecaf4795692028c2378efaMichel Dänzer for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) 188626553f327394b835cecaf4795692028c2378efaMichel Dänzer Writer.AddTypeRef(T->getExceptionType(I), Record); 189c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) { 190626553f327394b835cecaf4795692028c2378efaMichel Dänzer Writer.AddStmt(T->getNoexceptExpr()); 191626553f327394b835cecaf4795692028c2378efaMichel Dänzer } 1921f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Code = TYPE_FUNCTION_PROTO; 1931f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin} 1941f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin 1951f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusinvoid ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { 1961f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Writer.AddDeclRef(T->getDecl(), Record); 1971f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Code = TYPE_UNRESOLVED_USING; 1981f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin} 1991f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin 2001f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusinvoid ASTTypeWriter::VisitTypedefType(const TypedefType *T) { 201c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Writer.AddDeclRef(T->getDecl(), Record); 202c7653a83330e5ea63ad3a566da15155e216c6cb4Zack Rusin assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); 203493d599af4f617d52323e0368e65da29ba4638aaZack Rusin Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record); 2041f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Code = TYPE_TYPEDEF; 205c7653a83330e5ea63ad3a566da15155e216c6cb4Zack Rusin} 206c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin 20721cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusinvoid ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { 20821cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin Writer.AddStmt(T->getUnderlyingExpr()); 209f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin Code = TYPE_TYPEOF_EXPR; 2102048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin} 211c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin 212c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusinvoid ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { 213c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Writer.AddTypeRef(T->getUnderlyingType(), Record); 214f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin Code = TYPE_TYPEOF; 2152048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin} 2162048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin 2172048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusinvoid ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { 2181f5b568fbeda9e48f0ea6473cf8193e9502bb21aZack Rusin Writer.AddStmt(T->getUnderlyingExpr()); 2192048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin Code = TYPE_DECLTYPE; 220c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin} 22192676b9fe6356a8974830c47c0191d1ca57a0741Roland Scheidegger 22292676b9fe6356a8974830c47c0191d1ca57a0741Roland Scheideggervoid ASTTypeWriter::VisitAutoType(const AutoType *T) { 2232048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin Writer.AddTypeRef(T->getDeducedType(), Record); 22492676b9fe6356a8974830c47c0191d1ca57a0741Roland Scheidegger Code = TYPE_AUTO; 22592676b9fe6356a8974830c47c0191d1ca57a0741Roland Scheidegger} 22692676b9fe6356a8974830c47c0191d1ca57a0741Roland Scheidegger 22792676b9fe6356a8974830c47c0191d1ca57a0741Roland Scheideggervoid ASTTypeWriter::VisitTagType(const TagType *T) { 2282048182e868a759c3198b3cbaf2dd1d366fe0a21Zack Rusin Record.push_back(T->isDependentType()); 229319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin Writer.AddDeclRef(T->getDecl(), Record); 230f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin assert(!T->isBeingDefined() && 231f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin "Cannot serialize in the middle of a type definition"); 2325438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz} 233c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin 234c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusinvoid ASTTypeWriter::VisitRecordType(const RecordType *T) { 2355438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz VisitTagType(T); 2365438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Code = TYPE_RECORD; 2375438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz} 2385438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz 2395438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantzvoid ASTTypeWriter::VisitEnumType(const EnumType *T) { 24054d1b718b897742bf424f61f911e4ca8bbffa689Marcin Slusarz VisitTagType(T); 241c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin Code = TYPE_ENUM; 242c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin} 243c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin 244c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusinvoid ASTTypeWriter::VisitAttributedType(const AttributedType *T) { 245c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin Writer.AddTypeRef(T->getModifiedType(), Record); 246c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin Writer.AddTypeRef(T->getEquivalentType(), Record); 247c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin Record.push_back(T->getAttrKind()); 248c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin Code = TYPE_ATTRIBUTED; 249c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin} 250c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin 251c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusinvoid 2525438ee3ecfe5c25102d196fd6d7258201e27e6caJakob BornecrantzASTTypeWriter::VisitSubstTemplateTypeParmType( 253cb060f3b987c9fa07ebe06cf2e7e54d1eaded1e1Jakob Bornecrantz const SubstTemplateTypeParmType *T) { 2545438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); 25554d1b718b897742bf424f61f911e4ca8bbffa689Marcin Slusarz Writer.AddTypeRef(T->getReplacementType(), Record); 2565438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; 2575438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz} 2585438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz 2595438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantzvoid 2605438ee3ecfe5c25102d196fd6d7258201e27e6caJakob BornecrantzASTTypeWriter::VisitSubstTemplateTypeParmPackType( 2615438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz const SubstTemplateTypeParmPackType *T) { 2625438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); 2635438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddTemplateArgument(T->getArgumentPack(), Record); 2645438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK; 2655438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz} 2665438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz 2675438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantzvoid 2685438ee3ecfe5c25102d196fd6d7258201e27e6caJakob BornecrantzASTTypeWriter::VisitTemplateSpecializationType( 2695438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz const TemplateSpecializationType *T) { 2705438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Record.push_back(T->isDependentType()); 2715438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddTemplateName(T->getTemplateName(), Record); 2725438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Record.push_back(T->getNumArgs()); 2735438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end(); 2745438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz ArgI != ArgE; ++ArgI) 2755438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddTemplateArgument(*ArgI, Record); 2765438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() 2775438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz : T->getCanonicalTypeInternal(), 2785438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Record); 2795438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Code = TYPE_TEMPLATE_SPECIALIZATION; 2805438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz} 2815438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz 2825438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantzvoid 2835438ee3ecfe5c25102d196fd6d7258201e27e6caJakob BornecrantzASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { 2845438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz VisitArrayType(T); 2855438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddStmt(T->getSizeExpr()); 2865438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Writer.AddSourceRange(T->getBracketsRange(), Record); 2875438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Code = TYPE_DEPENDENT_SIZED_ARRAY; 2885438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz} 2895438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz 2905438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantzvoid 2915438ee3ecfe5c25102d196fd6d7258201e27e6caJakob BornecrantzASTTypeWriter::VisitDependentSizedExtVectorType( 2925438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz const DependentSizedExtVectorType *T) { 293f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin // FIXME: Serialize this type (C++ only) 294f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin assert(false && "Cannot serialize dependent sized extended vector types"); 2958bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin} 296c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin 2975438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantzvoid 298f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack RusinASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { 2998bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin Record.push_back(T->getDepth()); 3008bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin Record.push_back(T->getIndex()); 3018bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin Record.push_back(T->isParameterPack()); 3026be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddIdentifierRef(T->getName(), Record); 3036be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Code = TYPE_TEMPLATE_TYPE_PARM; 3048bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin} 3052cfbbc76e445d88bdac7dd4dd22aaf36bbc8e4ccZack Rusin 3062cfbbc76e445d88bdac7dd4dd22aaf36bbc8e4ccZack Rusinvoid 3072cfbbc76e445d88bdac7dd4dd22aaf36bbc8e4ccZack RusinASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { 308a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusin Record.push_back(T->getKeyword()); 309a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusin Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 31007f9ad5c322ce409fdd4b86e3913f7cc085520b5Zack Rusin Writer.AddIdentifierRef(T->getIdentifier(), Record); 31107f9ad5c322ce409fdd4b86e3913f7cc085520b5Zack Rusin Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() 3127edda9350acbf84b63ad67af8053fb07785637cbMichel Dänzer : T->getCanonicalTypeInternal(), 3137edda9350acbf84b63ad67af8053fb07785637cbMichel Dänzer Record); 3143bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer Code = TYPE_DEPENDENT_NAME; 3156be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin} 316a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusin 317a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusinvoid 318a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack RusinASTTypeWriter::VisitDependentTemplateSpecializationType( 319a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusin const DependentTemplateSpecializationType *T) { 320a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusin Record.push_back(T->getKeyword()); 321a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusin Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 322a8cbb1563213086f58d3b82b6d0755a59eb43c79Zack Rusin Writer.AddIdentifierRef(T->getIdentifier(), Record); 3235438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Record.push_back(T->getNumArgs()); 324c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin for (DependentTemplateSpecializationType::iterator 3258bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin I = T->begin(), E = T->end(); I != E; ++I) 3268bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin Writer.AddTemplateArgument(*I, Record); 3278bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; 3288bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin} 3298bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin 3302cfbbc76e445d88bdac7dd4dd22aaf36bbc8e4ccZack Rusinvoid ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { 3312cfbbc76e445d88bdac7dd4dd22aaf36bbc8e4ccZack Rusin Writer.AddTypeRef(T->getPattern(), Record); 332b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin if (llvm::Optional<unsigned> NumExpansions = T->getNumExpansions()) 333b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin Record.push_back(*NumExpansions + 1); 334b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin else 335b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin Record.push_back(0); 336b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin Code = TYPE_PACK_EXPANSION; 337b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin} 338b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin 339b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusinvoid ASTTypeWriter::VisitParenType(const ParenType *T) { 340b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin Writer.AddTypeRef(T->getInnerType(), Record); 3415438ee3ecfe5c25102d196fd6d7258201e27e6caJakob Bornecrantz Code = TYPE_PAREN; 342c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin} 3438bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusin 3448bdce0c3a7b3e3798de736ef4ce72431d777901cZack Rusinvoid ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { 345319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin Record.push_back(T->getKeyword()); 346319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 347319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin Writer.AddTypeRef(T->getNamedType(), Record); 348f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin Code = TYPE_ELABORATED; 349f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin} 350f1c0a4b2f4b0054a3371fcaf5121bf53ef29b756Zack Rusin 351f1c0a4b2f4b0054a3371fcaf5121bf53ef29b756Zack Rusinvoid ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { 352f1c0a4b2f4b0054a3371fcaf5121bf53ef29b756Zack Rusin Writer.AddDeclRef(T->getDecl(), Record); 3530a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); 3540a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Code = TYPE_INJECTED_CLASS_NAME; 3550a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin} 3560a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin 357f1c0a4b2f4b0054a3371fcaf5121bf53ef29b756Zack Rusinvoid ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 358fe20edf959c4ec565ef29f2556e03ce36e0c259fMarcin Slusarz Writer.AddDeclRef(T->getDecl(), Record); 3590a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Code = TYPE_OBJC_INTERFACE; 360ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger} 361ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger 362ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheideggervoid ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { 3630a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Writer.AddTypeRef(T->getBaseType(), Record); 36491c366359ce0bf5f450fd1d774b771c95ed2f651Zack Rusin Record.push_back(T->getNumProtocols()); 36591c366359ce0bf5f450fd1d774b771c95ed2f651Zack Rusin for (ObjCObjectType::qual_iterator I = T->qual_begin(), 3660a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin E = T->qual_end(); I != E; ++I) 3670a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Writer.AddDeclRef(*I, Record); 3680a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Code = TYPE_OBJC_OBJECT; 3690a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin} 370b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin 371b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusinvoid 372b17c885a8aa88ef06f384330d59aeb23b73350bbZack RusinASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 373ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger Writer.AddTypeRef(T->getPointeeType(), Record); 374b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin Code = TYPE_OBJC_OBJECT_POINTER; 375b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin} 376b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin 377b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusinnamespace { 378b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin 379b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusinclass TypeLocWriter : public TypeLocVisitor<TypeLocWriter> { 380b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin ASTWriter &Writer; 381b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin ASTWriter::RecordDataImpl &Record; 382b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin 383b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusinpublic: 384b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) 385b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin : Writer(Writer), Record(Record) { } 386b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin 387b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin#define ABSTRACT_TYPELOC(CLASS, PARENT) 388b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin#define TYPELOC(CLASS, PARENT) \ 389ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 390ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger#include "clang/AST/TypeLocNodes.def" 391ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger 392ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); 393ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); 394ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger}; 395b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin 3960a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin} 3970a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin 3980a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusinvoid TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 399d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin // nothing to do 400d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin} 401a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 402a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getBuiltinLoc(), Record); 403a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin if (TL.needsExtraLocalData()) { 404a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(TL.getWrittenTypeSpec()); 405d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Record.push_back(TL.getWrittenSignSpec()); 406d6b58a97c2f94ca54852414103c4ac2832279f2fZack Rusin Record.push_back(TL.getWrittenWidthSpec()); 407a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(TL.hasModeAttr()); 408a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin } 409a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 4100a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusinvoid TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4110a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 412b17c885a8aa88ef06f384330d59aeb23b73350bbZack Rusin} 413ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheideggervoid TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { 414ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger Writer.AddSourceLocation(TL.getStarLoc(), Record); 415ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger} 416ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheideggervoid TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 417ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger Writer.AddSourceLocation(TL.getCaretLoc(), Record); 418ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger} 4190a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusinvoid TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 420f1c0a4b2f4b0054a3371fcaf5121bf53ef29b756Zack Rusin Writer.AddSourceLocation(TL.getAmpLoc(), Record); 421c61d3fe8bddcbcf750c5f057a45b262fea92ca5eBrian Paul} 422c61d3fe8bddcbcf750c5f057a45b262fea92ca5eBrian Paulvoid TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4230a2681128622b0c0a22b68c95309cc70a237cc5cZack Rusin Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record); 424c61d3fe8bddcbcf750c5f057a45b262fea92ca5eBrian Paul} 425c61d3fe8bddcbcf750c5f057a45b262fea92ca5eBrian Paulvoid TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 426c61d3fe8bddcbcf750c5f057a45b262fea92ca5eBrian Paul Writer.AddSourceLocation(TL.getStarLoc(), Record); 427f1c0a4b2f4b0054a3371fcaf5121bf53ef29b756Zack Rusin Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record); 428f1c0a4b2f4b0054a3371fcaf5121bf53ef29b756Zack Rusin} 4299ccbadb22d74c649a634c515cd1123fe96781357Zack Rusinvoid TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4309ccbadb22d74c649a634c515cd1123fe96781357Zack Rusin Writer.AddSourceLocation(TL.getLBracketLoc(), Record); 431a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getRBracketLoc(), Record); 432a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(TL.getSizeExpr() ? 1 : 0); 433a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin if (TL.getSizeExpr()) 434a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddStmt(TL.getSizeExpr()); 435a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 436a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 437bec5230a1ff3998d0f184fc2b7437b51082c329fZack Rusin VisitArrayTypeLoc(TL); 438bec5230a1ff3998d0f184fc2b7437b51082c329fZack Rusin} 439a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 440bec5230a1ff3998d0f184fc2b7437b51082c329fZack Rusin VisitArrayTypeLoc(TL); 441a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 442bec5230a1ff3998d0f184fc2b7437b51082c329fZack Rusinvoid TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 443a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin VisitArrayTypeLoc(TL); 444bec5230a1ff3998d0f184fc2b7437b51082c329fZack Rusin} 445bec5230a1ff3998d0f184fc2b7437b51082c329fZack Rusinvoid TypeLocWriter::VisitDependentSizedArrayTypeLoc( 446a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin DependentSizedArrayTypeLoc TL) { 447a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin VisitArrayTypeLoc(TL); 448a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 449a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( 450a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin DependentSizedExtVectorTypeLoc TL) { 451a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 452a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 453a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { 454a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 455a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 456a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 457a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 458a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 459a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 460a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record); 461a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record); 462a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Record.push_back(TL.getTrailingReturn()); 463a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 464a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddDeclRef(TL.getArg(i), Record); 465a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 466a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 467a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin VisitFunctionTypeLoc(TL); 468a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 46921cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusinvoid TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 47021cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin VisitFunctionTypeLoc(TL); 47121cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin} 47221cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusinvoid TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 473f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 474f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin} 475f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusinvoid TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 476f9a3fce09044fbfe9a9b973d33b31cfe826d1386Zack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 47721cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin} 4784c7001462607e6e99e474d6271dd481d3f8f201cRoland Scheideggervoid TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4797fbdbad5c02e3d5bfbf0e641e2aec224e39fa974Keith Whitwell Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 4804236493899b9ccfcc8df3dcf81697776621fa1f8Keith Whitwell Writer.AddSourceLocation(TL.getLParenLoc(), Record); 4814236493899b9ccfcc8df3dcf81697776621fa1f8Keith Whitwell Writer.AddSourceLocation(TL.getRParenLoc(), Record); 4824236493899b9ccfcc8df3dcf81697776621fa1f8Keith Whitwell} 4837fbdbad5c02e3d5bfbf0e641e2aec224e39fa974Keith Whitwellvoid TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 484c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 485c712f3374626d96f9c08c3571a5572bcee60a5f2Zack Rusin Writer.AddSourceLocation(TL.getLParenLoc(), Record); 48691c366359ce0bf5f450fd1d774b771c95ed2f651Zack Rusin Writer.AddSourceLocation(TL.getRParenLoc(), Record); 48791c366359ce0bf5f450fd1d774b771c95ed2f651Zack Rusin Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); 4889ccbadb22d74c649a634c515cd1123fe96781357Zack Rusin} 489a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 490a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 491e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin} 492e521bf7706a5527ad5750baef78feaa961f73eccZack Rusinvoid TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { 493e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 494e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin} 495e521bf7706a5527ad5750baef78feaa961f73eccZack Rusinvoid TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { 496e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 497e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin} 498ecfe1352ccce802c9299c76d600c4d2f33352701Keith Whitwellvoid TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { 499ecfe1352ccce802c9299c76d600c4d2f33352701Keith Whitwell Writer.AddSourceLocation(TL.getNameLoc(), Record); 50089bb33fb20e69d9fa5325da10abf31d61d51d371Zack Rusin} 50121cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusinvoid TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 50221cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin Writer.AddSourceLocation(TL.getAttrNameLoc(), Record); 50321cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin if (TL.hasAttrOperand()) { 50421cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin SourceRange range = TL.getAttrOperandParensRange(); 50521cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin Writer.AddSourceLocation(range.getBegin(), Record); 50621cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin Writer.AddSourceLocation(range.getEnd(), Record); 50721cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin } 508811aa02c7a0f4804189a8978395f07d27fb726ecZack Rusin if (TL.hasAttrExprOperand()) { 5094322346f3fd03788a79d056ca7bce2db25bc9d88Zack Rusin Expr *operand = TL.getAttrExprOperand(); 5104322346f3fd03788a79d056ca7bce2db25bc9d88Zack Rusin Record.push_back(operand ? 1 : 0); 5114322346f3fd03788a79d056ca7bce2db25bc9d88Zack Rusin if (operand) Writer.AddStmt(operand); 512319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin } else if (TL.hasAttrEnumOperand()) { 513319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record); 514a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin } 515a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 516a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 517a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 518a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin} 519a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusinvoid TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( 520a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin SubstTemplateTypeParmTypeLoc TL) { 521a39a3cc14e816cc91a81028a27c4dbd4816cdc9dZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 522e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin} 523e521bf7706a5527ad5750baef78feaa961f73eccZack Rusinvoid TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( 524ac8662c29dbf96b456d23308c1bc459eea63e36cRoland Scheidegger SubstTemplateTypeParmPackTypeLoc TL) { 525e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 526e521bf7706a5527ad5750baef78feaa961f73eccZack Rusin} 527811aa02c7a0f4804189a8978395f07d27fb726ecZack Rusinvoid TypeLocWriter::VisitTemplateSpecializationTypeLoc( 52821cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin TemplateSpecializationTypeLoc TL) { 52921cce6afb03bf9b9adfc6d8a1a446bb3ef22c7a8Zack Rusin Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); 5303167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 5313167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 5323167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 5333167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), 5344c7001462607e6e99e474d6271dd481d3f8f201cRoland Scheidegger TL.getArgLoc(i).getLocInfo(), Record); 5356be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin} 5366be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusinvoid TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { 5376be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddSourceLocation(TL.getLParenLoc(), Record); 5383bcb9a858f482c21bc7c4d0fcd3571e25ea95090Michel Dänzer Writer.AddSourceLocation(TL.getRParenLoc(), Record); 5396be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin} 5406be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusinvoid TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 541ef7746217176ba251dc6a5deb90c308c9964ed7bZack Rusin Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 5426be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 5436be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin} 5446be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusinvoid TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 5456be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 5466be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin} 5476be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusinvoid TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 5486be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 5496be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 5506be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 5516be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin} 5524236493899b9ccfcc8df3dcf81697776621fa1f8Keith Whitwellvoid TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( 5534236493899b9ccfcc8df3dcf81697776621fa1f8Keith Whitwell DependentTemplateSpecializationTypeLoc TL) { 554c4af8ce69e1a7105b0178da8a085b73ab984e432Zack Rusin Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 555c61d3fe8bddcbcf750c5f057a45b262fea92ca5eBrian Paul Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 556c61d3fe8bddcbcf750c5f057a45b262fea92ca5eBrian Paul Writer.AddSourceLocation(TL.getNameLoc(), Record); 5576be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 558319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 559319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 560319a588238b4c0c58f8f8807e1143ad79cd8f698Zack Rusin Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), 5616be1a98ab9d64584c3852b97e2f1d63697f7bf76Zack Rusin TL.getArgLoc(I).getLocInfo(), Record); 5624322346f3fd03788a79d056ca7bce2db25bc9d88Zack Rusin} 5634322346f3fd03788a79d056ca7bce2db25bc9d88Zack Rusinvoid TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 564ecfe1352ccce802c9299c76d600c4d2f33352701Keith Whitwell Writer.AddSourceLocation(TL.getEllipsisLoc(), Record); 56553d2fa46e7fa19d0cb7dec74efcd407ab6163c80Zack Rusin} 5663167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusinvoid TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 5673167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin Writer.AddSourceLocation(TL.getNameLoc(), Record); 5683167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin} 5693167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusinvoid TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 5703167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin Record.push_back(TL.hasBaseTypeAsWritten()); 5713167c2e8a0a248c290ae8bfff23c88db8f39cd11Zack Rusin Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 5724322346f3fd03788a79d056ca7bce2db25bc9d88Zack Rusin Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 5734322346f3fd03788a79d056ca7bce2db25bc9d88Zack Rusin for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 57457d0934bc562c7a0de0c79fb0263ab3569eed002Zack Rusin Writer.AddSourceLocation(TL.getProtocolLoc(i), Record); 57557d0934bc562c7a0de0c79fb0263ab3569eed002Zack Rusin} 576fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwellvoid TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 577fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell Writer.AddSourceLocation(TL.getStarLoc(), Record); 578fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell} 579fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell 580fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell//===----------------------------------------------------------------------===// 581fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell// ASTWriter Implementation 582fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell//===----------------------------------------------------------------------===// 583fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell 584fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwellstatic void EmitBlockID(unsigned ID, const char *Name, 585fa799f81dec1b72e59008b7029d94a00bcf821bbKeith Whitwell llvm::BitstreamWriter &Stream, 586 ASTWriter::RecordDataImpl &Record) { 587 Record.clear(); 588 Record.push_back(ID); 589 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); 590 591 // Emit the block name if present. 592 if (Name == 0 || Name[0] == 0) return; 593 Record.clear(); 594 while (*Name) 595 Record.push_back(*Name++); 596 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); 597} 598 599static void EmitRecordID(unsigned ID, const char *Name, 600 llvm::BitstreamWriter &Stream, 601 ASTWriter::RecordDataImpl &Record) { 602 Record.clear(); 603 Record.push_back(ID); 604 while (*Name) 605 Record.push_back(*Name++); 606 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); 607} 608 609static void AddStmtsExprs(llvm::BitstreamWriter &Stream, 610 ASTWriter::RecordDataImpl &Record) { 611#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 612 RECORD(STMT_STOP); 613 RECORD(STMT_NULL_PTR); 614 RECORD(STMT_NULL); 615 RECORD(STMT_COMPOUND); 616 RECORD(STMT_CASE); 617 RECORD(STMT_DEFAULT); 618 RECORD(STMT_LABEL); 619 RECORD(STMT_IF); 620 RECORD(STMT_SWITCH); 621 RECORD(STMT_WHILE); 622 RECORD(STMT_DO); 623 RECORD(STMT_FOR); 624 RECORD(STMT_GOTO); 625 RECORD(STMT_INDIRECT_GOTO); 626 RECORD(STMT_CONTINUE); 627 RECORD(STMT_BREAK); 628 RECORD(STMT_RETURN); 629 RECORD(STMT_DECL); 630 RECORD(STMT_ASM); 631 RECORD(EXPR_PREDEFINED); 632 RECORD(EXPR_DECL_REF); 633 RECORD(EXPR_INTEGER_LITERAL); 634 RECORD(EXPR_FLOATING_LITERAL); 635 RECORD(EXPR_IMAGINARY_LITERAL); 636 RECORD(EXPR_STRING_LITERAL); 637 RECORD(EXPR_CHARACTER_LITERAL); 638 RECORD(EXPR_PAREN); 639 RECORD(EXPR_UNARY_OPERATOR); 640 RECORD(EXPR_SIZEOF_ALIGN_OF); 641 RECORD(EXPR_ARRAY_SUBSCRIPT); 642 RECORD(EXPR_CALL); 643 RECORD(EXPR_MEMBER); 644 RECORD(EXPR_BINARY_OPERATOR); 645 RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); 646 RECORD(EXPR_CONDITIONAL_OPERATOR); 647 RECORD(EXPR_IMPLICIT_CAST); 648 RECORD(EXPR_CSTYLE_CAST); 649 RECORD(EXPR_COMPOUND_LITERAL); 650 RECORD(EXPR_EXT_VECTOR_ELEMENT); 651 RECORD(EXPR_INIT_LIST); 652 RECORD(EXPR_DESIGNATED_INIT); 653 RECORD(EXPR_IMPLICIT_VALUE_INIT); 654 RECORD(EXPR_VA_ARG); 655 RECORD(EXPR_ADDR_LABEL); 656 RECORD(EXPR_STMT); 657 RECORD(EXPR_CHOOSE); 658 RECORD(EXPR_GNU_NULL); 659 RECORD(EXPR_SHUFFLE_VECTOR); 660 RECORD(EXPR_BLOCK); 661 RECORD(EXPR_BLOCK_DECL_REF); 662 RECORD(EXPR_GENERIC_SELECTION); 663 RECORD(EXPR_OBJC_STRING_LITERAL); 664 RECORD(EXPR_OBJC_ENCODE); 665 RECORD(EXPR_OBJC_SELECTOR_EXPR); 666 RECORD(EXPR_OBJC_PROTOCOL_EXPR); 667 RECORD(EXPR_OBJC_IVAR_REF_EXPR); 668 RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); 669 RECORD(EXPR_OBJC_KVC_REF_EXPR); 670 RECORD(EXPR_OBJC_MESSAGE_EXPR); 671 RECORD(STMT_OBJC_FOR_COLLECTION); 672 RECORD(STMT_OBJC_CATCH); 673 RECORD(STMT_OBJC_FINALLY); 674 RECORD(STMT_OBJC_AT_TRY); 675 RECORD(STMT_OBJC_AT_SYNCHRONIZED); 676 RECORD(STMT_OBJC_AT_THROW); 677 RECORD(EXPR_CXX_OPERATOR_CALL); 678 RECORD(EXPR_CXX_CONSTRUCT); 679 RECORD(EXPR_CXX_STATIC_CAST); 680 RECORD(EXPR_CXX_DYNAMIC_CAST); 681 RECORD(EXPR_CXX_REINTERPRET_CAST); 682 RECORD(EXPR_CXX_CONST_CAST); 683 RECORD(EXPR_CXX_FUNCTIONAL_CAST); 684 RECORD(EXPR_CXX_BOOL_LITERAL); 685 RECORD(EXPR_CXX_NULL_PTR_LITERAL); 686 RECORD(EXPR_CXX_TYPEID_EXPR); 687 RECORD(EXPR_CXX_TYPEID_TYPE); 688 RECORD(EXPR_CXX_UUIDOF_EXPR); 689 RECORD(EXPR_CXX_UUIDOF_TYPE); 690 RECORD(EXPR_CXX_THIS); 691 RECORD(EXPR_CXX_THROW); 692 RECORD(EXPR_CXX_DEFAULT_ARG); 693 RECORD(EXPR_CXX_BIND_TEMPORARY); 694 RECORD(EXPR_CXX_SCALAR_VALUE_INIT); 695 RECORD(EXPR_CXX_NEW); 696 RECORD(EXPR_CXX_DELETE); 697 RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR); 698 RECORD(EXPR_EXPR_WITH_CLEANUPS); 699 RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER); 700 RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF); 701 RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT); 702 RECORD(EXPR_CXX_UNRESOLVED_MEMBER); 703 RECORD(EXPR_CXX_UNRESOLVED_LOOKUP); 704 RECORD(EXPR_CXX_UNARY_TYPE_TRAIT); 705 RECORD(EXPR_CXX_NOEXCEPT); 706 RECORD(EXPR_OPAQUE_VALUE); 707 RECORD(EXPR_BINARY_TYPE_TRAIT); 708 RECORD(EXPR_PACK_EXPANSION); 709 RECORD(EXPR_SIZEOF_PACK); 710 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK); 711 RECORD(EXPR_CUDA_KERNEL_CALL); 712#undef RECORD 713} 714 715void ASTWriter::WriteBlockInfoBlock() { 716 RecordData Record; 717 Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); 718 719#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) 720#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 721 722 // AST Top-Level Block. 723 BLOCK(AST_BLOCK); 724 RECORD(ORIGINAL_FILE_NAME); 725 RECORD(TYPE_OFFSET); 726 RECORD(DECL_OFFSET); 727 RECORD(LANGUAGE_OPTIONS); 728 RECORD(METADATA); 729 RECORD(IDENTIFIER_OFFSET); 730 RECORD(IDENTIFIER_TABLE); 731 RECORD(EXTERNAL_DEFINITIONS); 732 RECORD(SPECIAL_TYPES); 733 RECORD(STATISTICS); 734 RECORD(TENTATIVE_DEFINITIONS); 735 RECORD(UNUSED_FILESCOPED_DECLS); 736 RECORD(LOCALLY_SCOPED_EXTERNAL_DECLS); 737 RECORD(SELECTOR_OFFSETS); 738 RECORD(METHOD_POOL); 739 RECORD(PP_COUNTER_VALUE); 740 RECORD(SOURCE_LOCATION_OFFSETS); 741 RECORD(SOURCE_LOCATION_PRELOADS); 742 RECORD(STAT_CACHE); 743 RECORD(EXT_VECTOR_DECLS); 744 RECORD(VERSION_CONTROL_BRANCH_REVISION); 745 RECORD(MACRO_DEFINITION_OFFSETS); 746 RECORD(CHAINED_METADATA); 747 RECORD(REFERENCED_SELECTOR_POOL); 748 RECORD(TU_UPDATE_LEXICAL); 749 RECORD(REDECLS_UPDATE_LATEST); 750 RECORD(SEMA_DECL_REFS); 751 RECORD(WEAK_UNDECLARED_IDENTIFIERS); 752 RECORD(PENDING_IMPLICIT_INSTANTIATIONS); 753 RECORD(DECL_REPLACEMENTS); 754 RECORD(UPDATE_VISIBLE); 755 RECORD(DECL_UPDATE_OFFSETS); 756 RECORD(DECL_UPDATES); 757 RECORD(CXX_BASE_SPECIFIER_OFFSETS); 758 RECORD(DIAG_PRAGMA_MAPPINGS); 759 RECORD(CUDA_SPECIAL_DECL_REFS); 760 RECORD(HEADER_SEARCH_TABLE); 761 RECORD(FP_PRAGMA_OPTIONS); 762 RECORD(OPENCL_EXTENSIONS); 763 764 // SourceManager Block. 765 BLOCK(SOURCE_MANAGER_BLOCK); 766 RECORD(SM_SLOC_FILE_ENTRY); 767 RECORD(SM_SLOC_BUFFER_ENTRY); 768 RECORD(SM_SLOC_BUFFER_BLOB); 769 RECORD(SM_SLOC_INSTANTIATION_ENTRY); 770 RECORD(SM_LINE_TABLE); 771 772 // Preprocessor Block. 773 BLOCK(PREPROCESSOR_BLOCK); 774 RECORD(PP_MACRO_OBJECT_LIKE); 775 RECORD(PP_MACRO_FUNCTION_LIKE); 776 RECORD(PP_TOKEN); 777 778 // Decls and Types block. 779 BLOCK(DECLTYPES_BLOCK); 780 RECORD(TYPE_EXT_QUAL); 781 RECORD(TYPE_COMPLEX); 782 RECORD(TYPE_POINTER); 783 RECORD(TYPE_BLOCK_POINTER); 784 RECORD(TYPE_LVALUE_REFERENCE); 785 RECORD(TYPE_RVALUE_REFERENCE); 786 RECORD(TYPE_MEMBER_POINTER); 787 RECORD(TYPE_CONSTANT_ARRAY); 788 RECORD(TYPE_INCOMPLETE_ARRAY); 789 RECORD(TYPE_VARIABLE_ARRAY); 790 RECORD(TYPE_VECTOR); 791 RECORD(TYPE_EXT_VECTOR); 792 RECORD(TYPE_FUNCTION_PROTO); 793 RECORD(TYPE_FUNCTION_NO_PROTO); 794 RECORD(TYPE_TYPEDEF); 795 RECORD(TYPE_TYPEOF_EXPR); 796 RECORD(TYPE_TYPEOF); 797 RECORD(TYPE_RECORD); 798 RECORD(TYPE_ENUM); 799 RECORD(TYPE_OBJC_INTERFACE); 800 RECORD(TYPE_OBJC_OBJECT); 801 RECORD(TYPE_OBJC_OBJECT_POINTER); 802 RECORD(TYPE_DECLTYPE); 803 RECORD(TYPE_ELABORATED); 804 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM); 805 RECORD(TYPE_UNRESOLVED_USING); 806 RECORD(TYPE_INJECTED_CLASS_NAME); 807 RECORD(TYPE_OBJC_OBJECT); 808 RECORD(TYPE_TEMPLATE_TYPE_PARM); 809 RECORD(TYPE_TEMPLATE_SPECIALIZATION); 810 RECORD(TYPE_DEPENDENT_NAME); 811 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION); 812 RECORD(TYPE_DEPENDENT_SIZED_ARRAY); 813 RECORD(TYPE_PAREN); 814 RECORD(TYPE_PACK_EXPANSION); 815 RECORD(TYPE_ATTRIBUTED); 816 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK); 817 RECORD(DECL_TRANSLATION_UNIT); 818 RECORD(DECL_TYPEDEF); 819 RECORD(DECL_ENUM); 820 RECORD(DECL_RECORD); 821 RECORD(DECL_ENUM_CONSTANT); 822 RECORD(DECL_FUNCTION); 823 RECORD(DECL_OBJC_METHOD); 824 RECORD(DECL_OBJC_INTERFACE); 825 RECORD(DECL_OBJC_PROTOCOL); 826 RECORD(DECL_OBJC_IVAR); 827 RECORD(DECL_OBJC_AT_DEFS_FIELD); 828 RECORD(DECL_OBJC_CLASS); 829 RECORD(DECL_OBJC_FORWARD_PROTOCOL); 830 RECORD(DECL_OBJC_CATEGORY); 831 RECORD(DECL_OBJC_CATEGORY_IMPL); 832 RECORD(DECL_OBJC_IMPLEMENTATION); 833 RECORD(DECL_OBJC_COMPATIBLE_ALIAS); 834 RECORD(DECL_OBJC_PROPERTY); 835 RECORD(DECL_OBJC_PROPERTY_IMPL); 836 RECORD(DECL_FIELD); 837 RECORD(DECL_VAR); 838 RECORD(DECL_IMPLICIT_PARAM); 839 RECORD(DECL_PARM_VAR); 840 RECORD(DECL_FILE_SCOPE_ASM); 841 RECORD(DECL_BLOCK); 842 RECORD(DECL_CONTEXT_LEXICAL); 843 RECORD(DECL_CONTEXT_VISIBLE); 844 RECORD(DECL_NAMESPACE); 845 RECORD(DECL_NAMESPACE_ALIAS); 846 RECORD(DECL_USING); 847 RECORD(DECL_USING_SHADOW); 848 RECORD(DECL_USING_DIRECTIVE); 849 RECORD(DECL_UNRESOLVED_USING_VALUE); 850 RECORD(DECL_UNRESOLVED_USING_TYPENAME); 851 RECORD(DECL_LINKAGE_SPEC); 852 RECORD(DECL_CXX_RECORD); 853 RECORD(DECL_CXX_METHOD); 854 RECORD(DECL_CXX_CONSTRUCTOR); 855 RECORD(DECL_CXX_DESTRUCTOR); 856 RECORD(DECL_CXX_CONVERSION); 857 RECORD(DECL_ACCESS_SPEC); 858 RECORD(DECL_FRIEND); 859 RECORD(DECL_FRIEND_TEMPLATE); 860 RECORD(DECL_CLASS_TEMPLATE); 861 RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION); 862 RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION); 863 RECORD(DECL_FUNCTION_TEMPLATE); 864 RECORD(DECL_TEMPLATE_TYPE_PARM); 865 RECORD(DECL_NON_TYPE_TEMPLATE_PARM); 866 RECORD(DECL_TEMPLATE_TEMPLATE_PARM); 867 RECORD(DECL_STATIC_ASSERT); 868 RECORD(DECL_CXX_BASE_SPECIFIERS); 869 RECORD(DECL_INDIRECTFIELD); 870 RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK); 871 872 BLOCK(PREPROCESSOR_DETAIL_BLOCK); 873 RECORD(PPD_MACRO_INSTANTIATION); 874 RECORD(PPD_MACRO_DEFINITION); 875 RECORD(PPD_INCLUSION_DIRECTIVE); 876 877 // Statements and Exprs can occur in the Decls and Types block. 878 AddStmtsExprs(Stream, Record); 879#undef RECORD 880#undef BLOCK 881 Stream.ExitBlock(); 882} 883 884/// \brief Adjusts the given filename to only write out the portion of the 885/// filename that is not part of the system root directory. 886/// 887/// \param Filename the file name to adjust. 888/// 889/// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and 890/// the returned filename will be adjusted by this system root. 891/// 892/// \returns either the original filename (if it needs no adjustment) or the 893/// adjusted filename (which points into the @p Filename parameter). 894static const char * 895adjustFilenameForRelocatablePCH(const char *Filename, const char *isysroot) { 896 assert(Filename && "No file name to adjust?"); 897 898 if (!isysroot) 899 return Filename; 900 901 // Verify that the filename and the system root have the same prefix. 902 unsigned Pos = 0; 903 for (; Filename[Pos] && isysroot[Pos]; ++Pos) 904 if (Filename[Pos] != isysroot[Pos]) 905 return Filename; // Prefixes don't match. 906 907 // We hit the end of the filename before we hit the end of the system root. 908 if (!Filename[Pos]) 909 return Filename; 910 911 // If the file name has a '/' at the current position, skip over the '/'. 912 // We distinguish sysroot-based includes from absolute includes by the 913 // absence of '/' at the beginning of sysroot-based includes. 914 if (Filename[Pos] == '/') 915 ++Pos; 916 917 return Filename + Pos; 918} 919 920/// \brief Write the AST metadata (e.g., i686-apple-darwin9). 921void ASTWriter::WriteMetadata(ASTContext &Context, const char *isysroot, 922 const std::string &OutputFile) { 923 using namespace llvm; 924 925 // Metadata 926 const TargetInfo &Target = Context.Target; 927 BitCodeAbbrev *MetaAbbrev = new BitCodeAbbrev(); 928 MetaAbbrev->Add(BitCodeAbbrevOp( 929 Chain ? CHAINED_METADATA : METADATA)); 930 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST major 931 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST minor 932 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major 933 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor 934 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable 935 // Target triple or chained PCH name 936 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 937 unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev); 938 939 RecordData Record; 940 Record.push_back(Chain ? CHAINED_METADATA : METADATA); 941 Record.push_back(VERSION_MAJOR); 942 Record.push_back(VERSION_MINOR); 943 Record.push_back(CLANG_VERSION_MAJOR); 944 Record.push_back(CLANG_VERSION_MINOR); 945 Record.push_back(isysroot != 0); 946 // FIXME: This writes the absolute path for chained headers. 947 const std::string &BlobStr = Chain ? Chain->getFileName() : Target.getTriple().getTriple(); 948 Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, BlobStr); 949 950 // Original file name 951 SourceManager &SM = Context.getSourceManager(); 952 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 953 BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev(); 954 FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE_NAME)); 955 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 956 unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); 957 958 llvm::SmallString<128> MainFilePath(MainFile->getName()); 959 960 llvm::sys::fs::make_absolute(MainFilePath); 961 962 const char *MainFileNameStr = MainFilePath.c_str(); 963 MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, 964 isysroot); 965 RecordData Record; 966 Record.push_back(ORIGINAL_FILE_NAME); 967 Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr); 968 } 969 970 // Original PCH directory 971 if (!OutputFile.empty() && OutputFile != "-") { 972 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 973 Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR)); 974 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 975 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 976 977 llvm::SmallString<128> OutputPath(OutputFile); 978 979 llvm::sys::fs::make_absolute(OutputPath); 980 StringRef origDir = llvm::sys::path::parent_path(OutputPath); 981 982 RecordData Record; 983 Record.push_back(ORIGINAL_PCH_DIR); 984 Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); 985 } 986 987 // Repository branch/version information. 988 BitCodeAbbrev *RepoAbbrev = new BitCodeAbbrev(); 989 RepoAbbrev->Add(BitCodeAbbrevOp(VERSION_CONTROL_BRANCH_REVISION)); 990 RepoAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag 991 unsigned RepoAbbrevCode = Stream.EmitAbbrev(RepoAbbrev); 992 Record.clear(); 993 Record.push_back(VERSION_CONTROL_BRANCH_REVISION); 994 Stream.EmitRecordWithBlob(RepoAbbrevCode, Record, 995 getClangFullRepositoryVersion()); 996} 997 998/// \brief Write the LangOptions structure. 999void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) { 1000 RecordData Record; 1001 Record.push_back(LangOpts.Trigraphs); 1002 Record.push_back(LangOpts.BCPLComment); // BCPL-style '//' comments. 1003 Record.push_back(LangOpts.DollarIdents); // '$' allowed in identifiers. 1004 Record.push_back(LangOpts.AsmPreprocessor); // Preprocessor in asm mode. 1005 Record.push_back(LangOpts.GNUMode); // True in gnu99 mode false in c99 mode (etc) 1006 Record.push_back(LangOpts.GNUKeywords); // Allow GNU-extension keywords 1007 Record.push_back(LangOpts.ImplicitInt); // C89 implicit 'int'. 1008 Record.push_back(LangOpts.Digraphs); // C94, C99 and C++ 1009 Record.push_back(LangOpts.HexFloats); // C99 Hexadecimal float constants. 1010 Record.push_back(LangOpts.C99); // C99 Support 1011 Record.push_back(LangOpts.C1X); // C1X Support 1012 Record.push_back(LangOpts.Microsoft); // Microsoft extensions. 1013 // LangOpts.MSCVersion is ignored because all it does it set a macro, which is 1014 // already saved elsewhere. 1015 Record.push_back(LangOpts.CPlusPlus); // C++ Support 1016 Record.push_back(LangOpts.CPlusPlus0x); // C++0x Support 1017 Record.push_back(LangOpts.CXXOperatorNames); // Treat C++ operator names as keywords. 1018 1019 Record.push_back(LangOpts.ObjC1); // Objective-C 1 support enabled. 1020 Record.push_back(LangOpts.ObjC2); // Objective-C 2 support enabled. 1021 Record.push_back(LangOpts.ObjCNonFragileABI); // Objective-C 1022 // modern abi enabled. 1023 Record.push_back(LangOpts.ObjCNonFragileABI2); // Objective-C enhanced 1024 // modern abi enabled. 1025 Record.push_back(LangOpts.AppleKext); // Apple's kernel extensions ABI 1026 Record.push_back(LangOpts.ObjCDefaultSynthProperties); // Objective-C auto-synthesized 1027 // properties enabled. 1028 Record.push_back(LangOpts.NoConstantCFStrings); // non cfstring generation enabled.. 1029 1030 Record.push_back(LangOpts.PascalStrings); // Allow Pascal strings 1031 Record.push_back(LangOpts.WritableStrings); // Allow writable strings 1032 Record.push_back(LangOpts.LaxVectorConversions); 1033 Record.push_back(LangOpts.AltiVec); 1034 Record.push_back(LangOpts.Exceptions); // Support exception handling. 1035 Record.push_back(LangOpts.ObjCExceptions); 1036 Record.push_back(LangOpts.CXXExceptions); 1037 Record.push_back(LangOpts.SjLjExceptions); 1038 1039 Record.push_back(LangOpts.MSBitfields); // MS-compatible structure layout 1040 Record.push_back(LangOpts.NeXTRuntime); // Use NeXT runtime. 1041 Record.push_back(LangOpts.Freestanding); // Freestanding implementation 1042 Record.push_back(LangOpts.NoBuiltin); // Do not use builtin functions (-fno-builtin) 1043 1044 // Whether static initializers are protected by locks. 1045 Record.push_back(LangOpts.ThreadsafeStatics); 1046 Record.push_back(LangOpts.POSIXThreads); 1047 Record.push_back(LangOpts.Blocks); // block extension to C 1048 Record.push_back(LangOpts.EmitAllDecls); // Emit all declarations, even if 1049 // they are unused. 1050 Record.push_back(LangOpts.MathErrno); // Math functions must respect errno 1051 // (modulo the platform support). 1052 1053 Record.push_back(LangOpts.getSignedOverflowBehavior()); 1054 Record.push_back(LangOpts.HeinousExtensions); 1055 1056 Record.push_back(LangOpts.Optimize); // Whether __OPTIMIZE__ should be defined. 1057 Record.push_back(LangOpts.OptimizeSize); // Whether __OPTIMIZE_SIZE__ should be 1058 // defined. 1059 Record.push_back(LangOpts.Static); // Should __STATIC__ be defined (as 1060 // opposed to __DYNAMIC__). 1061 Record.push_back(LangOpts.PICLevel); // The value for __PIC__, if non-zero. 1062 1063 Record.push_back(LangOpts.GNUInline); // Should GNU inline semantics be 1064 // used (instead of C99 semantics). 1065 Record.push_back(LangOpts.NoInline); // Should __NO_INLINE__ be defined. 1066 Record.push_back(LangOpts.Deprecated); // Should __DEPRECATED be defined. 1067 Record.push_back(LangOpts.AccessControl); // Whether C++ access control should 1068 // be enabled. 1069 Record.push_back(LangOpts.CharIsSigned); // Whether char is a signed or 1070 // unsigned type 1071 Record.push_back(LangOpts.ShortWChar); // force wchar_t to be unsigned short 1072 Record.push_back(LangOpts.ShortEnums); // Should the enum type be equivalent 1073 // to the smallest integer type with 1074 // enough room. 1075 Record.push_back(LangOpts.getGCMode()); 1076 Record.push_back(LangOpts.getVisibilityMode()); 1077 Record.push_back(LangOpts.getStackProtectorMode()); 1078 Record.push_back(LangOpts.InstantiationDepth); 1079 Record.push_back(LangOpts.OpenCL); 1080 Record.push_back(LangOpts.CUDA); 1081 Record.push_back(LangOpts.CatchUndefined); 1082 Record.push_back(LangOpts.DefaultFPContract); 1083 Record.push_back(LangOpts.ElideConstructors); 1084 Record.push_back(LangOpts.SpellChecking); 1085 Record.push_back(LangOpts.MRTD); 1086 Stream.EmitRecord(LANGUAGE_OPTIONS, Record); 1087} 1088 1089//===----------------------------------------------------------------------===// 1090// stat cache Serialization 1091//===----------------------------------------------------------------------===// 1092 1093namespace { 1094// Trait used for the on-disk hash table of stat cache results. 1095class ASTStatCacheTrait { 1096public: 1097 typedef const char * key_type; 1098 typedef key_type key_type_ref; 1099 1100 typedef struct stat data_type; 1101 typedef const data_type &data_type_ref; 1102 1103 static unsigned ComputeHash(const char *path) { 1104 return llvm::HashString(path); 1105 } 1106 1107 std::pair<unsigned,unsigned> 1108 EmitKeyDataLength(llvm::raw_ostream& Out, const char *path, 1109 data_type_ref Data) { 1110 unsigned StrLen = strlen(path); 1111 clang::io::Emit16(Out, StrLen); 1112 unsigned DataLen = 4 + 4 + 2 + 8 + 8; 1113 clang::io::Emit8(Out, DataLen); 1114 return std::make_pair(StrLen + 1, DataLen); 1115 } 1116 1117 void EmitKey(llvm::raw_ostream& Out, const char *path, unsigned KeyLen) { 1118 Out.write(path, KeyLen); 1119 } 1120 1121 void EmitData(llvm::raw_ostream &Out, key_type_ref, 1122 data_type_ref Data, unsigned DataLen) { 1123 using namespace clang::io; 1124 uint64_t Start = Out.tell(); (void)Start; 1125 1126 Emit32(Out, (uint32_t) Data.st_ino); 1127 Emit32(Out, (uint32_t) Data.st_dev); 1128 Emit16(Out, (uint16_t) Data.st_mode); 1129 Emit64(Out, (uint64_t) Data.st_mtime); 1130 Emit64(Out, (uint64_t) Data.st_size); 1131 1132 assert(Out.tell() - Start == DataLen && "Wrong data length"); 1133 } 1134}; 1135} // end anonymous namespace 1136 1137/// \brief Write the stat() system call cache to the AST file. 1138void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) { 1139 // Build the on-disk hash table containing information about every 1140 // stat() call. 1141 OnDiskChainedHashTableGenerator<ASTStatCacheTrait> Generator; 1142 unsigned NumStatEntries = 0; 1143 for (MemorizeStatCalls::iterator Stat = StatCalls.begin(), 1144 StatEnd = StatCalls.end(); 1145 Stat != StatEnd; ++Stat, ++NumStatEntries) { 1146 const char *Filename = Stat->first(); 1147 Generator.insert(Filename, Stat->second); 1148 } 1149 1150 // Create the on-disk hash table in a buffer. 1151 llvm::SmallString<4096> StatCacheData; 1152 uint32_t BucketOffset; 1153 { 1154 llvm::raw_svector_ostream Out(StatCacheData); 1155 // Make sure that no bucket is at offset 0 1156 clang::io::Emit32(Out, 0); 1157 BucketOffset = Generator.Emit(Out); 1158 } 1159 1160 // Create a blob abbreviation 1161 using namespace llvm; 1162 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1163 Abbrev->Add(BitCodeAbbrevOp(STAT_CACHE)); 1164 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1165 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1166 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1167 unsigned StatCacheAbbrev = Stream.EmitAbbrev(Abbrev); 1168 1169 // Write the stat cache 1170 RecordData Record; 1171 Record.push_back(STAT_CACHE); 1172 Record.push_back(BucketOffset); 1173 Record.push_back(NumStatEntries); 1174 Stream.EmitRecordWithBlob(StatCacheAbbrev, Record, StatCacheData.str()); 1175} 1176 1177//===----------------------------------------------------------------------===// 1178// Source Manager Serialization 1179//===----------------------------------------------------------------------===// 1180 1181/// \brief Create an abbreviation for the SLocEntry that refers to a 1182/// file. 1183static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { 1184 using namespace llvm; 1185 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1186 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); 1187 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1188 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1189 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1190 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1191 // FileEntry fields. 1192 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size 1193 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time 1194 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1195 return Stream.EmitAbbrev(Abbrev); 1196} 1197 1198/// \brief Create an abbreviation for the SLocEntry that refers to a 1199/// buffer. 1200static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { 1201 using namespace llvm; 1202 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1203 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); 1204 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1205 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1206 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1207 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1208 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob 1209 return Stream.EmitAbbrev(Abbrev); 1210} 1211 1212/// \brief Create an abbreviation for the SLocEntry that refers to a 1213/// buffer's blob. 1214static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { 1215 using namespace llvm; 1216 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1217 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB)); 1218 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob 1219 return Stream.EmitAbbrev(Abbrev); 1220} 1221 1222/// \brief Create an abbreviation for the SLocEntry that refers to an 1223/// buffer. 1224static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &Stream) { 1225 using namespace llvm; 1226 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1227 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_INSTANTIATION_ENTRY)); 1228 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1229 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location 1230 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location 1231 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location 1232 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length 1233 return Stream.EmitAbbrev(Abbrev); 1234} 1235 1236namespace { 1237 // Trait used for the on-disk hash table of header search information. 1238 class HeaderFileInfoTrait { 1239 ASTWriter &Writer; 1240 HeaderSearch &HS; 1241 1242 public: 1243 HeaderFileInfoTrait(ASTWriter &Writer, HeaderSearch &HS) 1244 : Writer(Writer), HS(HS) { } 1245 1246 typedef const char *key_type; 1247 typedef key_type key_type_ref; 1248 1249 typedef HeaderFileInfo data_type; 1250 typedef const data_type &data_type_ref; 1251 1252 static unsigned ComputeHash(const char *path) { 1253 // The hash is based only on the filename portion of the key, so that the 1254 // reader can match based on filenames when symlinking or excess path 1255 // elements ("foo/../", "../") change the form of the name. However, 1256 // complete path is still the key. 1257 return llvm::HashString(llvm::sys::path::filename(path)); 1258 } 1259 1260 std::pair<unsigned,unsigned> 1261 EmitKeyDataLength(llvm::raw_ostream& Out, const char *path, 1262 data_type_ref Data) { 1263 unsigned StrLen = strlen(path); 1264 clang::io::Emit16(Out, StrLen); 1265 unsigned DataLen = 1 + 2 + 4; 1266 clang::io::Emit8(Out, DataLen); 1267 return std::make_pair(StrLen + 1, DataLen); 1268 } 1269 1270 void EmitKey(llvm::raw_ostream& Out, const char *path, unsigned KeyLen) { 1271 Out.write(path, KeyLen); 1272 } 1273 1274 void EmitData(llvm::raw_ostream &Out, key_type_ref, 1275 data_type_ref Data, unsigned DataLen) { 1276 using namespace clang::io; 1277 uint64_t Start = Out.tell(); (void)Start; 1278 1279 unsigned char Flags = (Data.isImport << 3) 1280 | (Data.DirInfo << 1) 1281 | Data.Resolved; 1282 Emit8(Out, (uint8_t)Flags); 1283 Emit16(Out, (uint16_t) Data.NumIncludes); 1284 1285 if (!Data.ControllingMacro) 1286 Emit32(Out, (uint32_t)Data.ControllingMacroID); 1287 else 1288 Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro)); 1289 assert(Out.tell() - Start == DataLen && "Wrong data length"); 1290 } 1291 }; 1292} // end anonymous namespace 1293 1294/// \brief Write the header search block for the list of files that 1295/// 1296/// \param HS The header search structure to save. 1297/// 1298/// \param Chain Whether we're creating a chained AST file. 1299void ASTWriter::WriteHeaderSearch(HeaderSearch &HS, const char* isysroot) { 1300 llvm::SmallVector<const FileEntry *, 16> FilesByUID; 1301 HS.getFileMgr().GetUniqueIDMapping(FilesByUID); 1302 1303 if (FilesByUID.size() > HS.header_file_size()) 1304 FilesByUID.resize(HS.header_file_size()); 1305 1306 HeaderFileInfoTrait GeneratorTrait(*this, HS); 1307 OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator; 1308 llvm::SmallVector<const char *, 4> SavedStrings; 1309 unsigned NumHeaderSearchEntries = 0; 1310 for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { 1311 const FileEntry *File = FilesByUID[UID]; 1312 if (!File) 1313 continue; 1314 1315 const HeaderFileInfo &HFI = HS.header_file_begin()[UID]; 1316 if (HFI.External && Chain) 1317 continue; 1318 1319 // Turn the file name into an absolute path, if it isn't already. 1320 const char *Filename = File->getName(); 1321 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1322 1323 // If we performed any translation on the file name at all, we need to 1324 // save this string, since the generator will refer to it later. 1325 if (Filename != File->getName()) { 1326 Filename = strdup(Filename); 1327 SavedStrings.push_back(Filename); 1328 } 1329 1330 Generator.insert(Filename, HFI, GeneratorTrait); 1331 ++NumHeaderSearchEntries; 1332 } 1333 1334 // Create the on-disk hash table in a buffer. 1335 llvm::SmallString<4096> TableData; 1336 uint32_t BucketOffset; 1337 { 1338 llvm::raw_svector_ostream Out(TableData); 1339 // Make sure that no bucket is at offset 0 1340 clang::io::Emit32(Out, 0); 1341 BucketOffset = Generator.Emit(Out, GeneratorTrait); 1342 } 1343 1344 // Create a blob abbreviation 1345 using namespace llvm; 1346 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1347 Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); 1348 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1349 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1350 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1351 unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); 1352 1353 // Write the stat cache 1354 RecordData Record; 1355 Record.push_back(HEADER_SEARCH_TABLE); 1356 Record.push_back(BucketOffset); 1357 Record.push_back(NumHeaderSearchEntries); 1358 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str()); 1359 1360 // Free all of the strings we had to duplicate. 1361 for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) 1362 free((void*)SavedStrings[I]); 1363} 1364 1365/// \brief Writes the block containing the serialized form of the 1366/// source manager. 1367/// 1368/// TODO: We should probably use an on-disk hash table (stored in a 1369/// blob), indexed based on the file name, so that we only create 1370/// entries for files that we actually need. In the common case (no 1371/// errors), we probably won't have to create file entries for any of 1372/// the files in the AST. 1373void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, 1374 const Preprocessor &PP, 1375 const char *isysroot) { 1376 RecordData Record; 1377 1378 // Enter the source manager block. 1379 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3); 1380 1381 // Abbreviations for the various kinds of source-location entries. 1382 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); 1383 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); 1384 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); 1385 unsigned SLocInstantiationAbbrv = CreateSLocInstantiationAbbrev(Stream); 1386 1387 // Write the line table. 1388 if (SourceMgr.hasLineTable()) { 1389 LineTableInfo &LineTable = SourceMgr.getLineTable(); 1390 1391 // Emit the file names 1392 Record.push_back(LineTable.getNumFilenames()); 1393 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) { 1394 // Emit the file name 1395 const char *Filename = LineTable.getFilename(I); 1396 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1397 unsigned FilenameLen = Filename? strlen(Filename) : 0; 1398 Record.push_back(FilenameLen); 1399 if (FilenameLen) 1400 Record.insert(Record.end(), Filename, Filename + FilenameLen); 1401 } 1402 1403 // Emit the line entries 1404 for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); 1405 L != LEnd; ++L) { 1406 // Emit the file ID 1407 Record.push_back(L->first); 1408 1409 // Emit the line entries 1410 Record.push_back(L->second.size()); 1411 for (std::vector<LineEntry>::iterator LE = L->second.begin(), 1412 LEEnd = L->second.end(); 1413 LE != LEEnd; ++LE) { 1414 Record.push_back(LE->FileOffset); 1415 Record.push_back(LE->LineNo); 1416 Record.push_back(LE->FilenameID); 1417 Record.push_back((unsigned)LE->FileKind); 1418 Record.push_back(LE->IncludeOffset); 1419 } 1420 } 1421 Stream.EmitRecord(SM_LINE_TABLE, Record); 1422 } 1423 1424 // Write out the source location entry table. We skip the first 1425 // entry, which is always the same dummy entry. 1426 std::vector<uint32_t> SLocEntryOffsets; 1427 RecordData PreloadSLocs; 1428 unsigned BaseSLocID = Chain ? Chain->getTotalNumSLocs() : 0; 1429 SLocEntryOffsets.reserve(SourceMgr.sloc_entry_size() - 1 - BaseSLocID); 1430 for (unsigned I = BaseSLocID + 1, N = SourceMgr.sloc_entry_size(); 1431 I != N; ++I) { 1432 // Get this source location entry. 1433 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getSLocEntry(I); 1434 1435 // Record the offset of this source-location entry. 1436 SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); 1437 1438 // Figure out which record code to use. 1439 unsigned Code; 1440 if (SLoc->isFile()) { 1441 if (SLoc->getFile().getContentCache()->OrigEntry) 1442 Code = SM_SLOC_FILE_ENTRY; 1443 else 1444 Code = SM_SLOC_BUFFER_ENTRY; 1445 } else 1446 Code = SM_SLOC_INSTANTIATION_ENTRY; 1447 Record.clear(); 1448 Record.push_back(Code); 1449 1450 Record.push_back(SLoc->getOffset()); 1451 if (SLoc->isFile()) { 1452 const SrcMgr::FileInfo &File = SLoc->getFile(); 1453 Record.push_back(File.getIncludeLoc().getRawEncoding()); 1454 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding 1455 Record.push_back(File.hasLineDirectives()); 1456 1457 const SrcMgr::ContentCache *Content = File.getContentCache(); 1458 if (Content->OrigEntry) { 1459 assert(Content->OrigEntry == Content->ContentsEntry && 1460 "Writing to AST an overriden file is not supported"); 1461 1462 // The source location entry is a file. The blob associated 1463 // with this entry is the file name. 1464 1465 // Emit size/modification time for this file. 1466 Record.push_back(Content->OrigEntry->getSize()); 1467 Record.push_back(Content->OrigEntry->getModificationTime()); 1468 1469 // Turn the file name into an absolute path, if it isn't already. 1470 const char *Filename = Content->OrigEntry->getName(); 1471 llvm::SmallString<128> FilePath(Filename); 1472 1473 // Ask the file manager to fixup the relative path for us. This will 1474 // honor the working directory. 1475 SourceMgr.getFileManager().FixupRelativePath(FilePath); 1476 1477 // FIXME: This call to make_absolute shouldn't be necessary, the 1478 // call to FixupRelativePath should always return an absolute path. 1479 llvm::sys::fs::make_absolute(FilePath); 1480 Filename = FilePath.c_str(); 1481 1482 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1483 Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename); 1484 } else { 1485 // The source location entry is a buffer. The blob associated 1486 // with this entry contains the contents of the buffer. 1487 1488 // We add one to the size so that we capture the trailing NULL 1489 // that is required by llvm::MemoryBuffer::getMemBuffer (on 1490 // the reader side). 1491 const llvm::MemoryBuffer *Buffer 1492 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 1493 const char *Name = Buffer->getBufferIdentifier(); 1494 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, 1495 llvm::StringRef(Name, strlen(Name) + 1)); 1496 Record.clear(); 1497 Record.push_back(SM_SLOC_BUFFER_BLOB); 1498 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, 1499 llvm::StringRef(Buffer->getBufferStart(), 1500 Buffer->getBufferSize() + 1)); 1501 1502 if (strcmp(Name, "<built-in>") == 0) 1503 PreloadSLocs.push_back(BaseSLocID + SLocEntryOffsets.size()); 1504 } 1505 } else { 1506 // The source location entry is an instantiation. 1507 const SrcMgr::InstantiationInfo &Inst = SLoc->getInstantiation(); 1508 Record.push_back(Inst.getSpellingLoc().getRawEncoding()); 1509 Record.push_back(Inst.getInstantiationLocStart().getRawEncoding()); 1510 Record.push_back(Inst.getInstantiationLocEnd().getRawEncoding()); 1511 1512 // Compute the token length for this macro expansion. 1513 unsigned NextOffset = SourceMgr.getNextOffset(); 1514 if (I + 1 != N) 1515 NextOffset = SourceMgr.getSLocEntry(I + 1).getOffset(); 1516 Record.push_back(NextOffset - SLoc->getOffset() - 1); 1517 Stream.EmitRecordWithAbbrev(SLocInstantiationAbbrv, Record); 1518 } 1519 } 1520 1521 Stream.ExitBlock(); 1522 1523 if (SLocEntryOffsets.empty()) 1524 return; 1525 1526 // Write the source-location offsets table into the AST block. This 1527 // table is used for lazily loading source-location information. 1528 using namespace llvm; 1529 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1530 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); 1531 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs 1532 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // next offset 1533 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets 1534 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); 1535 1536 Record.clear(); 1537 Record.push_back(SOURCE_LOCATION_OFFSETS); 1538 Record.push_back(SLocEntryOffsets.size()); 1539 unsigned BaseOffset = Chain ? Chain->getNextSLocOffset() : 0; 1540 Record.push_back(SourceMgr.getNextOffset() - BaseOffset); 1541 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, 1542 (const char *)data(SLocEntryOffsets), 1543 SLocEntryOffsets.size()*sizeof(SLocEntryOffsets[0])); 1544 1545 // Write the source location entry preloads array, telling the AST 1546 // reader which source locations entries it should load eagerly. 1547 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); 1548} 1549 1550//===----------------------------------------------------------------------===// 1551// Preprocessor Serialization 1552//===----------------------------------------------------------------------===// 1553 1554static int compareMacroDefinitions(const void *XPtr, const void *YPtr) { 1555 const std::pair<const IdentifierInfo *, MacroInfo *> &X = 1556 *(const std::pair<const IdentifierInfo *, MacroInfo *>*)XPtr; 1557 const std::pair<const IdentifierInfo *, MacroInfo *> &Y = 1558 *(const std::pair<const IdentifierInfo *, MacroInfo *>*)YPtr; 1559 return X.first->getName().compare(Y.first->getName()); 1560} 1561 1562/// \brief Writes the block containing the serialized form of the 1563/// preprocessor. 1564/// 1565void ASTWriter::WritePreprocessor(const Preprocessor &PP) { 1566 RecordData Record; 1567 1568 // If the preprocessor __COUNTER__ value has been bumped, remember it. 1569 if (PP.getCounterValue() != 0) { 1570 Record.push_back(PP.getCounterValue()); 1571 Stream.EmitRecord(PP_COUNTER_VALUE, Record); 1572 Record.clear(); 1573 } 1574 1575 // Enter the preprocessor block. 1576 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); 1577 1578 // If the AST file contains __DATE__ or __TIME__ emit a warning about this. 1579 // FIXME: use diagnostics subsystem for localization etc. 1580 if (PP.SawDateOrTime()) 1581 fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); 1582 1583 1584 // Loop over all the macro definitions that are live at the end of the file, 1585 // emitting each to the PP section. 1586 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 1587 1588 // Construct the list of macro definitions that need to be serialized. 1589 llvm::SmallVector<std::pair<const IdentifierInfo *, MacroInfo *>, 2> 1590 MacrosToEmit; 1591 llvm::SmallPtrSet<const IdentifierInfo*, 4> MacroDefinitionsSeen; 1592 for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0), 1593 E = PP.macro_end(Chain == 0); 1594 I != E; ++I) { 1595 MacroDefinitionsSeen.insert(I->first); 1596 MacrosToEmit.push_back(std::make_pair(I->first, I->second)); 1597 } 1598 1599 // Sort the set of macro definitions that need to be serialized by the 1600 // name of the macro, to provide a stable ordering. 1601 llvm::array_pod_sort(MacrosToEmit.begin(), MacrosToEmit.end(), 1602 &compareMacroDefinitions); 1603 1604 // Resolve any identifiers that defined macros at the time they were 1605 // deserialized, adding them to the list of macros to emit (if appropriate). 1606 for (unsigned I = 0, N = DeserializedMacroNames.size(); I != N; ++I) { 1607 IdentifierInfo *Name 1608 = const_cast<IdentifierInfo *>(DeserializedMacroNames[I]); 1609 if (Name->hasMacroDefinition() && MacroDefinitionsSeen.insert(Name)) 1610 MacrosToEmit.push_back(std::make_pair(Name, PP.getMacroInfo(Name))); 1611 } 1612 1613 for (unsigned I = 0, N = MacrosToEmit.size(); I != N; ++I) { 1614 const IdentifierInfo *Name = MacrosToEmit[I].first; 1615 MacroInfo *MI = MacrosToEmit[I].second; 1616 if (!MI) 1617 continue; 1618 1619 // Don't emit builtin macros like __LINE__ to the AST file unless they have 1620 // been redefined by the header (in which case they are not isBuiltinMacro). 1621 // Also skip macros from a AST file if we're chaining. 1622 1623 // FIXME: There is a (probably minor) optimization we could do here, if 1624 // the macro comes from the original PCH but the identifier comes from a 1625 // chained PCH, by storing the offset into the original PCH rather than 1626 // writing the macro definition a second time. 1627 if (MI->isBuiltinMacro() || 1628 (Chain && Name->isFromAST() && MI->isFromAST())) 1629 continue; 1630 1631 AddIdentifierRef(Name, Record); 1632 MacroOffsets[Name] = Stream.GetCurrentBitNo(); 1633 Record.push_back(MI->getDefinitionLoc().getRawEncoding()); 1634 Record.push_back(MI->isUsed()); 1635 1636 unsigned Code; 1637 if (MI->isObjectLike()) { 1638 Code = PP_MACRO_OBJECT_LIKE; 1639 } else { 1640 Code = PP_MACRO_FUNCTION_LIKE; 1641 1642 Record.push_back(MI->isC99Varargs()); 1643 Record.push_back(MI->isGNUVarargs()); 1644 Record.push_back(MI->getNumArgs()); 1645 for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end(); 1646 I != E; ++I) 1647 AddIdentifierRef(*I, Record); 1648 } 1649 1650 // If we have a detailed preprocessing record, record the macro definition 1651 // ID that corresponds to this macro. 1652 if (PPRec) 1653 Record.push_back(getMacroDefinitionID(PPRec->findMacroDefinition(MI))); 1654 1655 Stream.EmitRecord(Code, Record); 1656 Record.clear(); 1657 1658 // Emit the tokens array. 1659 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { 1660 // Note that we know that the preprocessor does not have any annotation 1661 // tokens in it because they are created by the parser, and thus can't be 1662 // in a macro definition. 1663 const Token &Tok = MI->getReplacementToken(TokNo); 1664 1665 Record.push_back(Tok.getLocation().getRawEncoding()); 1666 Record.push_back(Tok.getLength()); 1667 1668 // FIXME: When reading literal tokens, reconstruct the literal pointer if 1669 // it is needed. 1670 AddIdentifierRef(Tok.getIdentifierInfo(), Record); 1671 // FIXME: Should translate token kind to a stable encoding. 1672 Record.push_back(Tok.getKind()); 1673 // FIXME: Should translate token flags to a stable encoding. 1674 Record.push_back(Tok.getFlags()); 1675 1676 Stream.EmitRecord(PP_TOKEN, Record); 1677 Record.clear(); 1678 } 1679 ++NumMacros; 1680 } 1681 Stream.ExitBlock(); 1682 1683 if (PPRec) 1684 WritePreprocessorDetail(*PPRec); 1685} 1686 1687void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { 1688 if (PPRec.begin(Chain) == PPRec.end(Chain)) 1689 return; 1690 1691 // Enter the preprocessor block. 1692 Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); 1693 1694 // If the preprocessor has a preprocessing record, emit it. 1695 unsigned NumPreprocessingRecords = 0; 1696 using namespace llvm; 1697 1698 // Set up the abbreviation for 1699 unsigned InclusionAbbrev = 0; 1700 { 1701 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1702 Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); 1703 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // index 1704 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // start location 1705 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // end location 1706 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length 1707 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes 1708 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind 1709 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1710 InclusionAbbrev = Stream.EmitAbbrev(Abbrev); 1711 } 1712 1713 unsigned IndexBase = Chain ? PPRec.getNumPreallocatedEntities() : 0; 1714 RecordData Record; 1715 for (PreprocessingRecord::iterator E = PPRec.begin(Chain), 1716 EEnd = PPRec.end(Chain); 1717 E != EEnd; ++E) { 1718 Record.clear(); 1719 1720 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) { 1721 // Record this macro definition's location. 1722 MacroID ID = getMacroDefinitionID(MD); 1723 1724 // Don't write the macro definition if it is from another AST file. 1725 if (ID < FirstMacroID) 1726 continue; 1727 1728 // Notify the serialization listener that we're serializing this entity. 1729 if (SerializationListener) 1730 SerializationListener->SerializedPreprocessedEntity(*E, 1731 Stream.GetCurrentBitNo()); 1732 1733 unsigned Position = ID - FirstMacroID; 1734 if (Position != MacroDefinitionOffsets.size()) { 1735 if (Position > MacroDefinitionOffsets.size()) 1736 MacroDefinitionOffsets.resize(Position + 1); 1737 1738 MacroDefinitionOffsets[Position] = Stream.GetCurrentBitNo(); 1739 } else 1740 MacroDefinitionOffsets.push_back(Stream.GetCurrentBitNo()); 1741 1742 Record.push_back(IndexBase + NumPreprocessingRecords++); 1743 Record.push_back(ID); 1744 AddSourceLocation(MD->getSourceRange().getBegin(), Record); 1745 AddSourceLocation(MD->getSourceRange().getEnd(), Record); 1746 AddIdentifierRef(MD->getName(), Record); 1747 AddSourceLocation(MD->getLocation(), Record); 1748 Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); 1749 continue; 1750 } 1751 1752 // Notify the serialization listener that we're serializing this entity. 1753 if (SerializationListener) 1754 SerializationListener->SerializedPreprocessedEntity(*E, 1755 Stream.GetCurrentBitNo()); 1756 1757 if (MacroInstantiation *MI = dyn_cast<MacroInstantiation>(*E)) { 1758 Record.push_back(IndexBase + NumPreprocessingRecords++); 1759 AddSourceLocation(MI->getSourceRange().getBegin(), Record); 1760 AddSourceLocation(MI->getSourceRange().getEnd(), Record); 1761 AddIdentifierRef(MI->getName(), Record); 1762 Record.push_back(getMacroDefinitionID(MI->getDefinition())); 1763 Stream.EmitRecord(PPD_MACRO_INSTANTIATION, Record); 1764 continue; 1765 } 1766 1767 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) { 1768 Record.push_back(PPD_INCLUSION_DIRECTIVE); 1769 Record.push_back(IndexBase + NumPreprocessingRecords++); 1770 AddSourceLocation(ID->getSourceRange().getBegin(), Record); 1771 AddSourceLocation(ID->getSourceRange().getEnd(), Record); 1772 Record.push_back(ID->getFileName().size()); 1773 Record.push_back(ID->wasInQuotes()); 1774 Record.push_back(static_cast<unsigned>(ID->getKind())); 1775 llvm::SmallString<64> Buffer; 1776 Buffer += ID->getFileName(); 1777 Buffer += ID->getFile()->getName(); 1778 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); 1779 continue; 1780 } 1781 1782 llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); 1783 } 1784 Stream.ExitBlock(); 1785 1786 // Write the offsets table for the preprocessing record. 1787 if (NumPreprocessingRecords > 0) { 1788 // Write the offsets table for identifier IDs. 1789 using namespace llvm; 1790 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1791 Abbrev->Add(BitCodeAbbrevOp(MACRO_DEFINITION_OFFSETS)); 1792 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of records 1793 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macro defs 1794 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1795 unsigned MacroDefOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1796 1797 Record.clear(); 1798 Record.push_back(MACRO_DEFINITION_OFFSETS); 1799 Record.push_back(NumPreprocessingRecords); 1800 Record.push_back(MacroDefinitionOffsets.size()); 1801 Stream.EmitRecordWithBlob(MacroDefOffsetAbbrev, Record, 1802 (const char *)data(MacroDefinitionOffsets), 1803 MacroDefinitionOffsets.size() * sizeof(uint32_t)); 1804 } 1805} 1806 1807void ASTWriter::WritePragmaDiagnosticMappings(const Diagnostic &Diag) { 1808 RecordData Record; 1809 for (Diagnostic::DiagStatePointsTy::const_iterator 1810 I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end(); 1811 I != E; ++I) { 1812 const Diagnostic::DiagStatePoint &point = *I; 1813 if (point.Loc.isInvalid()) 1814 continue; 1815 1816 Record.push_back(point.Loc.getRawEncoding()); 1817 for (Diagnostic::DiagState::iterator 1818 I = point.State->begin(), E = point.State->end(); I != E; ++I) { 1819 unsigned diag = I->first, map = I->second; 1820 if (map & 0x10) { // mapping from a diagnostic pragma. 1821 Record.push_back(diag); 1822 Record.push_back(map & 0x7); 1823 } 1824 } 1825 Record.push_back(-1); // mark the end of the diag/map pairs for this 1826 // location. 1827 } 1828 1829 if (!Record.empty()) 1830 Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); 1831} 1832 1833void ASTWriter::WriteCXXBaseSpecifiersOffsets() { 1834 if (CXXBaseSpecifiersOffsets.empty()) 1835 return; 1836 1837 RecordData Record; 1838 1839 // Create a blob abbreviation for the C++ base specifiers offsets. 1840 using namespace llvm; 1841 1842 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1843 Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS)); 1844 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 1845 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1846 unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1847 1848 // Write the selector offsets table. 1849 Record.clear(); 1850 Record.push_back(CXX_BASE_SPECIFIER_OFFSETS); 1851 Record.push_back(CXXBaseSpecifiersOffsets.size()); 1852 Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record, 1853 (const char *)CXXBaseSpecifiersOffsets.data(), 1854 CXXBaseSpecifiersOffsets.size() * sizeof(uint32_t)); 1855} 1856 1857//===----------------------------------------------------------------------===// 1858// Type Serialization 1859//===----------------------------------------------------------------------===// 1860 1861/// \brief Write the representation of a type to the AST stream. 1862void ASTWriter::WriteType(QualType T) { 1863 TypeIdx &Idx = TypeIdxs[T]; 1864 if (Idx.getIndex() == 0) // we haven't seen this type before. 1865 Idx = TypeIdx(NextTypeID++); 1866 1867 assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); 1868 1869 // Record the offset for this type. 1870 unsigned Index = Idx.getIndex() - FirstTypeID; 1871 if (TypeOffsets.size() == Index) 1872 TypeOffsets.push_back(Stream.GetCurrentBitNo()); 1873 else if (TypeOffsets.size() < Index) { 1874 TypeOffsets.resize(Index + 1); 1875 TypeOffsets[Index] = Stream.GetCurrentBitNo(); 1876 } 1877 1878 RecordData Record; 1879 1880 // Emit the type's representation. 1881 ASTTypeWriter W(*this, Record); 1882 1883 if (T.hasLocalNonFastQualifiers()) { 1884 Qualifiers Qs = T.getLocalQualifiers(); 1885 AddTypeRef(T.getLocalUnqualifiedType(), Record); 1886 Record.push_back(Qs.getAsOpaqueValue()); 1887 W.Code = TYPE_EXT_QUAL; 1888 } else { 1889 switch (T->getTypeClass()) { 1890 // For all of the concrete, non-dependent types, call the 1891 // appropriate visitor function. 1892#define TYPE(Class, Base) \ 1893 case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break; 1894#define ABSTRACT_TYPE(Class, Base) 1895#include "clang/AST/TypeNodes.def" 1896 } 1897 } 1898 1899 // Emit the serialized record. 1900 Stream.EmitRecord(W.Code, Record); 1901 1902 // Flush any expressions that were written as part of this type. 1903 FlushStmts(); 1904} 1905 1906//===----------------------------------------------------------------------===// 1907// Declaration Serialization 1908//===----------------------------------------------------------------------===// 1909 1910/// \brief Write the block containing all of the declaration IDs 1911/// lexically declared within the given DeclContext. 1912/// 1913/// \returns the offset of the DECL_CONTEXT_LEXICAL block within the 1914/// bistream, or 0 if no block was written. 1915uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, 1916 DeclContext *DC) { 1917 if (DC->decls_empty()) 1918 return 0; 1919 1920 uint64_t Offset = Stream.GetCurrentBitNo(); 1921 RecordData Record; 1922 Record.push_back(DECL_CONTEXT_LEXICAL); 1923 llvm::SmallVector<KindDeclIDPair, 64> Decls; 1924 for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end(); 1925 D != DEnd; ++D) 1926 Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D))); 1927 1928 ++NumLexicalDeclContexts; 1929 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, 1930 reinterpret_cast<char*>(Decls.data()), 1931 Decls.size() * sizeof(KindDeclIDPair)); 1932 return Offset; 1933} 1934 1935void ASTWriter::WriteTypeDeclOffsets() { 1936 using namespace llvm; 1937 RecordData Record; 1938 1939 // Write the type offsets array 1940 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1941 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); 1942 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types 1943 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block 1944 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1945 Record.clear(); 1946 Record.push_back(TYPE_OFFSET); 1947 Record.push_back(TypeOffsets.size()); 1948 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, 1949 (const char *)data(TypeOffsets), 1950 TypeOffsets.size() * sizeof(TypeOffsets[0])); 1951 1952 // Write the declaration offsets array 1953 Abbrev = new BitCodeAbbrev(); 1954 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); 1955 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations 1956 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block 1957 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1958 Record.clear(); 1959 Record.push_back(DECL_OFFSET); 1960 Record.push_back(DeclOffsets.size()); 1961 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, 1962 (const char *)data(DeclOffsets), 1963 DeclOffsets.size() * sizeof(DeclOffsets[0])); 1964} 1965 1966//===----------------------------------------------------------------------===// 1967// Global Method Pool and Selector Serialization 1968//===----------------------------------------------------------------------===// 1969 1970namespace { 1971// Trait used for the on-disk hash table used in the method pool. 1972class ASTMethodPoolTrait { 1973 ASTWriter &Writer; 1974 1975public: 1976 typedef Selector key_type; 1977 typedef key_type key_type_ref; 1978 1979 struct data_type { 1980 SelectorID ID; 1981 ObjCMethodList Instance, Factory; 1982 }; 1983 typedef const data_type& data_type_ref; 1984 1985 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } 1986 1987 static unsigned ComputeHash(Selector Sel) { 1988 return serialization::ComputeHash(Sel); 1989 } 1990 1991 std::pair<unsigned,unsigned> 1992 EmitKeyDataLength(llvm::raw_ostream& Out, Selector Sel, 1993 data_type_ref Methods) { 1994 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); 1995 clang::io::Emit16(Out, KeyLen); 1996 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts 1997 for (const ObjCMethodList *Method = &Methods.Instance; Method; 1998 Method = Method->Next) 1999 if (Method->Method) 2000 DataLen += 4; 2001 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2002 Method = Method->Next) 2003 if (Method->Method) 2004 DataLen += 4; 2005 clang::io::Emit16(Out, DataLen); 2006 return std::make_pair(KeyLen, DataLen); 2007 } 2008 2009 void EmitKey(llvm::raw_ostream& Out, Selector Sel, unsigned) { 2010 uint64_t Start = Out.tell(); 2011 assert((Start >> 32) == 0 && "Selector key offset too large"); 2012 Writer.SetSelectorOffset(Sel, Start); 2013 unsigned N = Sel.getNumArgs(); 2014 clang::io::Emit16(Out, N); 2015 if (N == 0) 2016 N = 1; 2017 for (unsigned I = 0; I != N; ++I) 2018 clang::io::Emit32(Out, 2019 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); 2020 } 2021 2022 void EmitData(llvm::raw_ostream& Out, key_type_ref, 2023 data_type_ref Methods, unsigned DataLen) { 2024 uint64_t Start = Out.tell(); (void)Start; 2025 clang::io::Emit32(Out, Methods.ID); 2026 unsigned NumInstanceMethods = 0; 2027 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2028 Method = Method->Next) 2029 if (Method->Method) 2030 ++NumInstanceMethods; 2031 2032 unsigned NumFactoryMethods = 0; 2033 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2034 Method = Method->Next) 2035 if (Method->Method) 2036 ++NumFactoryMethods; 2037 2038 clang::io::Emit16(Out, NumInstanceMethods); 2039 clang::io::Emit16(Out, NumFactoryMethods); 2040 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2041 Method = Method->Next) 2042 if (Method->Method) 2043 clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 2044 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2045 Method = Method->Next) 2046 if (Method->Method) 2047 clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 2048 2049 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 2050 } 2051}; 2052} // end anonymous namespace 2053 2054/// \brief Write ObjC data: selectors and the method pool. 2055/// 2056/// The method pool contains both instance and factory methods, stored 2057/// in an on-disk hash table indexed by the selector. The hash table also 2058/// contains an empty entry for every other selector known to Sema. 2059void ASTWriter::WriteSelectors(Sema &SemaRef) { 2060 using namespace llvm; 2061 2062 // Do we have to do anything at all? 2063 if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) 2064 return; 2065 unsigned NumTableEntries = 0; 2066 // Create and write out the blob that contains selectors and the method pool. 2067 { 2068 OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator; 2069 ASTMethodPoolTrait Trait(*this); 2070 2071 // Create the on-disk hash table representation. We walk through every 2072 // selector we've seen and look it up in the method pool. 2073 SelectorOffsets.resize(NextSelectorID - FirstSelectorID); 2074 for (llvm::DenseMap<Selector, SelectorID>::iterator 2075 I = SelectorIDs.begin(), E = SelectorIDs.end(); 2076 I != E; ++I) { 2077 Selector S = I->first; 2078 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); 2079 ASTMethodPoolTrait::data_type Data = { 2080 I->second, 2081 ObjCMethodList(), 2082 ObjCMethodList() 2083 }; 2084 if (F != SemaRef.MethodPool.end()) { 2085 Data.Instance = F->second.first; 2086 Data.Factory = F->second.second; 2087 } 2088 // Only write this selector if it's not in an existing AST or something 2089 // changed. 2090 if (Chain && I->second < FirstSelectorID) { 2091 // Selector already exists. Did it change? 2092 bool changed = false; 2093 for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method; 2094 M = M->Next) { 2095 if (M->Method->getPCHLevel() == 0) 2096 changed = true; 2097 } 2098 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method; 2099 M = M->Next) { 2100 if (M->Method->getPCHLevel() == 0) 2101 changed = true; 2102 } 2103 if (!changed) 2104 continue; 2105 } else if (Data.Instance.Method || Data.Factory.Method) { 2106 // A new method pool entry. 2107 ++NumTableEntries; 2108 } 2109 Generator.insert(S, Data, Trait); 2110 } 2111 2112 // Create the on-disk hash table in a buffer. 2113 llvm::SmallString<4096> MethodPool; 2114 uint32_t BucketOffset; 2115 { 2116 ASTMethodPoolTrait Trait(*this); 2117 llvm::raw_svector_ostream Out(MethodPool); 2118 // Make sure that no bucket is at offset 0 2119 clang::io::Emit32(Out, 0); 2120 BucketOffset = Generator.Emit(Out, Trait); 2121 } 2122 2123 // Create a blob abbreviation 2124 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2125 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); 2126 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2127 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2128 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2129 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); 2130 2131 // Write the method pool 2132 RecordData Record; 2133 Record.push_back(METHOD_POOL); 2134 Record.push_back(BucketOffset); 2135 Record.push_back(NumTableEntries); 2136 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str()); 2137 2138 // Create a blob abbreviation for the selector table offsets. 2139 Abbrev = new BitCodeAbbrev(); 2140 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); 2141 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 2142 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2143 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2144 2145 // Write the selector offsets table. 2146 Record.clear(); 2147 Record.push_back(SELECTOR_OFFSETS); 2148 Record.push_back(SelectorOffsets.size()); 2149 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, 2150 (const char *)data(SelectorOffsets), 2151 SelectorOffsets.size() * 4); 2152 } 2153} 2154 2155/// \brief Write the selectors referenced in @selector expression into AST file. 2156void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { 2157 using namespace llvm; 2158 if (SemaRef.ReferencedSelectors.empty()) 2159 return; 2160 2161 RecordData Record; 2162 2163 // Note: this writes out all references even for a dependent AST. But it is 2164 // very tricky to fix, and given that @selector shouldn't really appear in 2165 // headers, probably not worth it. It's not a correctness issue. 2166 for (DenseMap<Selector, SourceLocation>::iterator S = 2167 SemaRef.ReferencedSelectors.begin(), 2168 E = SemaRef.ReferencedSelectors.end(); S != E; ++S) { 2169 Selector Sel = (*S).first; 2170 SourceLocation Loc = (*S).second; 2171 AddSelectorRef(Sel, Record); 2172 AddSourceLocation(Loc, Record); 2173 } 2174 Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record); 2175} 2176 2177//===----------------------------------------------------------------------===// 2178// Identifier Table Serialization 2179//===----------------------------------------------------------------------===// 2180 2181namespace { 2182class ASTIdentifierTableTrait { 2183 ASTWriter &Writer; 2184 Preprocessor &PP; 2185 2186 /// \brief Determines whether this is an "interesting" identifier 2187 /// that needs a full IdentifierInfo structure written into the hash 2188 /// table. 2189 static bool isInterestingIdentifier(const IdentifierInfo *II) { 2190 return II->isPoisoned() || 2191 II->isExtensionToken() || 2192 II->hasMacroDefinition() || 2193 II->getObjCOrBuiltinID() || 2194 II->getFETokenInfo<void>(); 2195 } 2196 2197public: 2198 typedef const IdentifierInfo* key_type; 2199 typedef key_type key_type_ref; 2200 2201 typedef IdentID data_type; 2202 typedef data_type data_type_ref; 2203 2204 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP) 2205 : Writer(Writer), PP(PP) { } 2206 2207 static unsigned ComputeHash(const IdentifierInfo* II) { 2208 return llvm::HashString(II->getName()); 2209 } 2210 2211 std::pair<unsigned,unsigned> 2212 EmitKeyDataLength(llvm::raw_ostream& Out, const IdentifierInfo* II, 2213 IdentID ID) { 2214 unsigned KeyLen = II->getLength() + 1; 2215 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 2216 if (isInterestingIdentifier(II)) { 2217 DataLen += 2; // 2 bytes for builtin ID, flags 2218 if (II->hasMacroDefinition() && 2219 !PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro()) 2220 DataLen += 4; 2221 for (IdentifierResolver::iterator D = IdentifierResolver::begin(II), 2222 DEnd = IdentifierResolver::end(); 2223 D != DEnd; ++D) 2224 DataLen += sizeof(DeclID); 2225 } 2226 clang::io::Emit16(Out, DataLen); 2227 // We emit the key length after the data length so that every 2228 // string is preceded by a 16-bit length. This matches the PTH 2229 // format for storing identifiers. 2230 clang::io::Emit16(Out, KeyLen); 2231 return std::make_pair(KeyLen, DataLen); 2232 } 2233 2234 void EmitKey(llvm::raw_ostream& Out, const IdentifierInfo* II, 2235 unsigned KeyLen) { 2236 // Record the location of the key data. This is used when generating 2237 // the mapping from persistent IDs to strings. 2238 Writer.SetIdentifierOffset(II, Out.tell()); 2239 Out.write(II->getNameStart(), KeyLen); 2240 } 2241 2242 void EmitData(llvm::raw_ostream& Out, const IdentifierInfo* II, 2243 IdentID ID, unsigned) { 2244 if (!isInterestingIdentifier(II)) { 2245 clang::io::Emit32(Out, ID << 1); 2246 return; 2247 } 2248 2249 clang::io::Emit32(Out, (ID << 1) | 0x01); 2250 uint32_t Bits = 0; 2251 bool hasMacroDefinition = 2252 II->hasMacroDefinition() && 2253 !PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro(); 2254 Bits = (uint32_t)II->getObjCOrBuiltinID(); 2255 Bits = (Bits << 1) | unsigned(hasMacroDefinition); 2256 Bits = (Bits << 1) | unsigned(II->isExtensionToken()); 2257 Bits = (Bits << 1) | unsigned(II->isPoisoned()); 2258 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); 2259 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); 2260 clang::io::Emit16(Out, Bits); 2261 2262 if (hasMacroDefinition) 2263 clang::io::Emit32(Out, Writer.getMacroOffset(II)); 2264 2265 // Emit the declaration IDs in reverse order, because the 2266 // IdentifierResolver provides the declarations as they would be 2267 // visible (e.g., the function "stat" would come before the struct 2268 // "stat"), but IdentifierResolver::AddDeclToIdentifierChain() 2269 // adds declarations to the end of the list (so we need to see the 2270 // struct "status" before the function "status"). 2271 // Only emit declarations that aren't from a chained PCH, though. 2272 llvm::SmallVector<Decl *, 16> Decls(IdentifierResolver::begin(II), 2273 IdentifierResolver::end()); 2274 for (llvm::SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(), 2275 DEnd = Decls.rend(); 2276 D != DEnd; ++D) 2277 clang::io::Emit32(Out, Writer.getDeclID(*D)); 2278 } 2279}; 2280} // end anonymous namespace 2281 2282/// \brief Write the identifier table into the AST file. 2283/// 2284/// The identifier table consists of a blob containing string data 2285/// (the actual identifiers themselves) and a separate "offsets" index 2286/// that maps identifier IDs to locations within the blob. 2287void ASTWriter::WriteIdentifierTable(Preprocessor &PP) { 2288 using namespace llvm; 2289 2290 // Create and write out the blob that contains the identifier 2291 // strings. 2292 { 2293 OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator; 2294 ASTIdentifierTableTrait Trait(*this, PP); 2295 2296 // Look for any identifiers that were named while processing the 2297 // headers, but are otherwise not needed. We add these to the hash 2298 // table to enable checking of the predefines buffer in the case 2299 // where the user adds new macro definitions when building the AST 2300 // file. 2301 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), 2302 IDEnd = PP.getIdentifierTable().end(); 2303 ID != IDEnd; ++ID) 2304 getIdentifierRef(ID->second); 2305 2306 // Create the on-disk hash table representation. We only store offsets 2307 // for identifiers that appear here for the first time. 2308 IdentifierOffsets.resize(NextIdentID - FirstIdentID); 2309 for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator 2310 ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); 2311 ID != IDEnd; ++ID) { 2312 assert(ID->first && "NULL identifier in identifier table"); 2313 if (!Chain || !ID->first->isFromAST()) 2314 Generator.insert(ID->first, ID->second, Trait); 2315 } 2316 2317 // Create the on-disk hash table in a buffer. 2318 llvm::SmallString<4096> IdentifierTable; 2319 uint32_t BucketOffset; 2320 { 2321 ASTIdentifierTableTrait Trait(*this, PP); 2322 llvm::raw_svector_ostream Out(IdentifierTable); 2323 // Make sure that no bucket is at offset 0 2324 clang::io::Emit32(Out, 0); 2325 BucketOffset = Generator.Emit(Out, Trait); 2326 } 2327 2328 // Create a blob abbreviation 2329 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2330 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); 2331 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2332 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2333 unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); 2334 2335 // Write the identifier table 2336 RecordData Record; 2337 Record.push_back(IDENTIFIER_TABLE); 2338 Record.push_back(BucketOffset); 2339 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str()); 2340 } 2341 2342 // Write the offsets table for identifier IDs. 2343 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2344 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); 2345 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers 2346 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2347 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2348 2349 RecordData Record; 2350 Record.push_back(IDENTIFIER_OFFSET); 2351 Record.push_back(IdentifierOffsets.size()); 2352 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, 2353 (const char *)data(IdentifierOffsets), 2354 IdentifierOffsets.size() * sizeof(uint32_t)); 2355} 2356 2357//===----------------------------------------------------------------------===// 2358// DeclContext's Name Lookup Table Serialization 2359//===----------------------------------------------------------------------===// 2360 2361namespace { 2362// Trait used for the on-disk hash table used in the method pool. 2363class ASTDeclContextNameLookupTrait { 2364 ASTWriter &Writer; 2365 2366public: 2367 typedef DeclarationName key_type; 2368 typedef key_type key_type_ref; 2369 2370 typedef DeclContext::lookup_result data_type; 2371 typedef const data_type& data_type_ref; 2372 2373 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { } 2374 2375 unsigned ComputeHash(DeclarationName Name) { 2376 llvm::FoldingSetNodeID ID; 2377 ID.AddInteger(Name.getNameKind()); 2378 2379 switch (Name.getNameKind()) { 2380 case DeclarationName::Identifier: 2381 ID.AddString(Name.getAsIdentifierInfo()->getName()); 2382 break; 2383 case DeclarationName::ObjCZeroArgSelector: 2384 case DeclarationName::ObjCOneArgSelector: 2385 case DeclarationName::ObjCMultiArgSelector: 2386 ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector())); 2387 break; 2388 case DeclarationName::CXXConstructorName: 2389 case DeclarationName::CXXDestructorName: 2390 case DeclarationName::CXXConversionFunctionName: 2391 ID.AddInteger(Writer.GetOrCreateTypeID(Name.getCXXNameType())); 2392 break; 2393 case DeclarationName::CXXOperatorName: 2394 ID.AddInteger(Name.getCXXOverloadedOperator()); 2395 break; 2396 case DeclarationName::CXXLiteralOperatorName: 2397 ID.AddString(Name.getCXXLiteralIdentifier()->getName()); 2398 case DeclarationName::CXXUsingDirective: 2399 break; 2400 } 2401 2402 return ID.ComputeHash(); 2403 } 2404 2405 std::pair<unsigned,unsigned> 2406 EmitKeyDataLength(llvm::raw_ostream& Out, DeclarationName Name, 2407 data_type_ref Lookup) { 2408 unsigned KeyLen = 1; 2409 switch (Name.getNameKind()) { 2410 case DeclarationName::Identifier: 2411 case DeclarationName::ObjCZeroArgSelector: 2412 case DeclarationName::ObjCOneArgSelector: 2413 case DeclarationName::ObjCMultiArgSelector: 2414 case DeclarationName::CXXConstructorName: 2415 case DeclarationName::CXXDestructorName: 2416 case DeclarationName::CXXConversionFunctionName: 2417 case DeclarationName::CXXLiteralOperatorName: 2418 KeyLen += 4; 2419 break; 2420 case DeclarationName::CXXOperatorName: 2421 KeyLen += 1; 2422 break; 2423 case DeclarationName::CXXUsingDirective: 2424 break; 2425 } 2426 clang::io::Emit16(Out, KeyLen); 2427 2428 // 2 bytes for num of decls and 4 for each DeclID. 2429 unsigned DataLen = 2 + 4 * (Lookup.second - Lookup.first); 2430 clang::io::Emit16(Out, DataLen); 2431 2432 return std::make_pair(KeyLen, DataLen); 2433 } 2434 2435 void EmitKey(llvm::raw_ostream& Out, DeclarationName Name, unsigned) { 2436 using namespace clang::io; 2437 2438 assert(Name.getNameKind() < 0x100 && "Invalid name kind ?"); 2439 Emit8(Out, Name.getNameKind()); 2440 switch (Name.getNameKind()) { 2441 case DeclarationName::Identifier: 2442 Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo())); 2443 break; 2444 case DeclarationName::ObjCZeroArgSelector: 2445 case DeclarationName::ObjCOneArgSelector: 2446 case DeclarationName::ObjCMultiArgSelector: 2447 Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector())); 2448 break; 2449 case DeclarationName::CXXConstructorName: 2450 case DeclarationName::CXXDestructorName: 2451 case DeclarationName::CXXConversionFunctionName: 2452 Emit32(Out, Writer.getTypeID(Name.getCXXNameType())); 2453 break; 2454 case DeclarationName::CXXOperatorName: 2455 assert(Name.getCXXOverloadedOperator() < 0x100 && "Invalid operator ?"); 2456 Emit8(Out, Name.getCXXOverloadedOperator()); 2457 break; 2458 case DeclarationName::CXXLiteralOperatorName: 2459 Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); 2460 break; 2461 case DeclarationName::CXXUsingDirective: 2462 break; 2463 } 2464 } 2465 2466 void EmitData(llvm::raw_ostream& Out, key_type_ref, 2467 data_type Lookup, unsigned DataLen) { 2468 uint64_t Start = Out.tell(); (void)Start; 2469 clang::io::Emit16(Out, Lookup.second - Lookup.first); 2470 for (; Lookup.first != Lookup.second; ++Lookup.first) 2471 clang::io::Emit32(Out, Writer.GetDeclRef(*Lookup.first)); 2472 2473 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 2474 } 2475}; 2476} // end anonymous namespace 2477 2478/// \brief Write the block containing all of the declaration IDs 2479/// visible from the given DeclContext. 2480/// 2481/// \returns the offset of the DECL_CONTEXT_VISIBLE block within the 2482/// bitstream, or 0 if no block was written. 2483uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, 2484 DeclContext *DC) { 2485 if (DC->getPrimaryContext() != DC) 2486 return 0; 2487 2488 // Since there is no name lookup into functions or methods, don't bother to 2489 // build a visible-declarations table for these entities. 2490 if (DC->isFunctionOrMethod()) 2491 return 0; 2492 2493 // If not in C++, we perform name lookup for the translation unit via the 2494 // IdentifierInfo chains, don't bother to build a visible-declarations table. 2495 // FIXME: In C++ we need the visible declarations in order to "see" the 2496 // friend declarations, is there a way to do this without writing the table ? 2497 if (DC->isTranslationUnit() && !Context.getLangOptions().CPlusPlus) 2498 return 0; 2499 2500 // Force the DeclContext to build a its name-lookup table. 2501 if (DC->hasExternalVisibleStorage()) 2502 DC->MaterializeVisibleDeclsFromExternalStorage(); 2503 else 2504 DC->lookup(DeclarationName()); 2505 2506 // Serialize the contents of the mapping used for lookup. Note that, 2507 // although we have two very different code paths, the serialized 2508 // representation is the same for both cases: a declaration name, 2509 // followed by a size, followed by references to the visible 2510 // declarations that have that name. 2511 uint64_t Offset = Stream.GetCurrentBitNo(); 2512 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); 2513 if (!Map || Map->empty()) 2514 return 0; 2515 2516 OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator; 2517 ASTDeclContextNameLookupTrait Trait(*this); 2518 2519 // Create the on-disk hash table representation. 2520 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 2521 D != DEnd; ++D) { 2522 DeclarationName Name = D->first; 2523 DeclContext::lookup_result Result = D->second.getLookupResult(); 2524 Generator.insert(Name, Result, Trait); 2525 } 2526 2527 // Create the on-disk hash table in a buffer. 2528 llvm::SmallString<4096> LookupTable; 2529 uint32_t BucketOffset; 2530 { 2531 llvm::raw_svector_ostream Out(LookupTable); 2532 // Make sure that no bucket is at offset 0 2533 clang::io::Emit32(Out, 0); 2534 BucketOffset = Generator.Emit(Out, Trait); 2535 } 2536 2537 // Write the lookup table 2538 RecordData Record; 2539 Record.push_back(DECL_CONTEXT_VISIBLE); 2540 Record.push_back(BucketOffset); 2541 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, 2542 LookupTable.str()); 2543 2544 Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record); 2545 ++NumVisibleDeclContexts; 2546 return Offset; 2547} 2548 2549/// \brief Write an UPDATE_VISIBLE block for the given context. 2550/// 2551/// UPDATE_VISIBLE blocks contain the declarations that are added to an existing 2552/// DeclContext in a dependent AST file. As such, they only exist for the TU 2553/// (in C++) and for namespaces. 2554void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { 2555 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); 2556 if (!Map || Map->empty()) 2557 return; 2558 2559 OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator; 2560 ASTDeclContextNameLookupTrait Trait(*this); 2561 2562 // Create the hash table. 2563 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 2564 D != DEnd; ++D) { 2565 DeclarationName Name = D->first; 2566 DeclContext::lookup_result Result = D->second.getLookupResult(); 2567 // For any name that appears in this table, the results are complete, i.e. 2568 // they overwrite results from previous PCHs. Merging is always a mess. 2569 Generator.insert(Name, Result, Trait); 2570 } 2571 2572 // Create the on-disk hash table in a buffer. 2573 llvm::SmallString<4096> LookupTable; 2574 uint32_t BucketOffset; 2575 { 2576 llvm::raw_svector_ostream Out(LookupTable); 2577 // Make sure that no bucket is at offset 0 2578 clang::io::Emit32(Out, 0); 2579 BucketOffset = Generator.Emit(Out, Trait); 2580 } 2581 2582 // Write the lookup table 2583 RecordData Record; 2584 Record.push_back(UPDATE_VISIBLE); 2585 Record.push_back(getDeclID(cast<Decl>(DC))); 2586 Record.push_back(BucketOffset); 2587 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str()); 2588} 2589 2590/// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. 2591void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { 2592 RecordData Record; 2593 Record.push_back(Opts.fp_contract); 2594 Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); 2595} 2596 2597/// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. 2598void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { 2599 if (!SemaRef.Context.getLangOptions().OpenCL) 2600 return; 2601 2602 const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); 2603 RecordData Record; 2604#define OPENCLEXT(nm) Record.push_back(Opts.nm); 2605#include "clang/Basic/OpenCLExtensions.def" 2606 Stream.EmitRecord(OPENCL_EXTENSIONS, Record); 2607} 2608 2609//===----------------------------------------------------------------------===// 2610// General Serialization Routines 2611//===----------------------------------------------------------------------===// 2612 2613/// \brief Write a record containing the given attributes. 2614void ASTWriter::WriteAttributes(const AttrVec &Attrs, RecordDataImpl &Record) { 2615 Record.push_back(Attrs.size()); 2616 for (AttrVec::const_iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){ 2617 const Attr * A = *i; 2618 Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs 2619 AddSourceLocation(A->getLocation(), Record); 2620 2621#include "clang/Serialization/AttrPCHWrite.inc" 2622 2623 } 2624} 2625 2626void ASTWriter::AddString(llvm::StringRef Str, RecordDataImpl &Record) { 2627 Record.push_back(Str.size()); 2628 Record.insert(Record.end(), Str.begin(), Str.end()); 2629} 2630 2631void ASTWriter::AddVersionTuple(const VersionTuple &Version, 2632 RecordDataImpl &Record) { 2633 Record.push_back(Version.getMajor()); 2634 if (llvm::Optional<unsigned> Minor = Version.getMinor()) 2635 Record.push_back(*Minor + 1); 2636 else 2637 Record.push_back(0); 2638 if (llvm::Optional<unsigned> Subminor = Version.getSubminor()) 2639 Record.push_back(*Subminor + 1); 2640 else 2641 Record.push_back(0); 2642} 2643 2644/// \brief Note that the identifier II occurs at the given offset 2645/// within the identifier table. 2646void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { 2647 IdentID ID = IdentifierIDs[II]; 2648 // Only store offsets new to this AST file. Other identifier names are looked 2649 // up earlier in the chain and thus don't need an offset. 2650 if (ID >= FirstIdentID) 2651 IdentifierOffsets[ID - FirstIdentID] = Offset; 2652} 2653 2654/// \brief Note that the selector Sel occurs at the given offset 2655/// within the method pool/selector table. 2656void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { 2657 unsigned ID = SelectorIDs[Sel]; 2658 assert(ID && "Unknown selector"); 2659 // Don't record offsets for selectors that are also available in a different 2660 // file. 2661 if (ID < FirstSelectorID) 2662 return; 2663 SelectorOffsets[ID - FirstSelectorID] = Offset; 2664} 2665 2666ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) 2667 : Stream(Stream), Chain(0), SerializationListener(0), 2668 FirstDeclID(1), NextDeclID(FirstDeclID), 2669 FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), 2670 FirstIdentID(1), NextIdentID(FirstIdentID), FirstSelectorID(1), 2671 NextSelectorID(FirstSelectorID), FirstMacroID(1), NextMacroID(FirstMacroID), 2672 CollectedStmts(&StmtsToEmit), 2673 NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), 2674 NumVisibleDeclContexts(0), FirstCXXBaseSpecifiersID(1), 2675 NextCXXBaseSpecifiersID(1) 2676{ 2677} 2678 2679void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2680 const std::string &OutputFile, 2681 const char *isysroot) { 2682 // Emit the file header. 2683 Stream.Emit((unsigned)'C', 8); 2684 Stream.Emit((unsigned)'P', 8); 2685 Stream.Emit((unsigned)'C', 8); 2686 Stream.Emit((unsigned)'H', 8); 2687 2688 WriteBlockInfoBlock(); 2689 2690 if (Chain) 2691 WriteASTChain(SemaRef, StatCalls, isysroot); 2692 else 2693 WriteASTCore(SemaRef, StatCalls, isysroot, OutputFile); 2694} 2695 2696void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2697 const char *isysroot, 2698 const std::string &OutputFile) { 2699 using namespace llvm; 2700 2701 ASTContext &Context = SemaRef.Context; 2702 Preprocessor &PP = SemaRef.PP; 2703 2704 // The translation unit is the first declaration we'll emit. 2705 DeclIDs[Context.getTranslationUnitDecl()] = 1; 2706 ++NextDeclID; 2707 DeclTypesToEmit.push(Context.getTranslationUnitDecl()); 2708 2709 // Make sure that we emit IdentifierInfos (and any attached 2710 // declarations) for builtins. 2711 { 2712 IdentifierTable &Table = PP.getIdentifierTable(); 2713 llvm::SmallVector<const char *, 32> BuiltinNames; 2714 Context.BuiltinInfo.GetBuiltinNames(BuiltinNames, 2715 Context.getLangOptions().NoBuiltin); 2716 for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) 2717 getIdentifierRef(&Table.get(BuiltinNames[I])); 2718 } 2719 2720 // Build a record containing all of the tentative definitions in this file, in 2721 // TentativeDefinitions order. Generally, this record will be empty for 2722 // headers. 2723 RecordData TentativeDefinitions; 2724 for (unsigned i = 0, e = SemaRef.TentativeDefinitions.size(); i != e; ++i) { 2725 AddDeclRef(SemaRef.TentativeDefinitions[i], TentativeDefinitions); 2726 } 2727 2728 // Build a record containing all of the file scoped decls in this file. 2729 RecordData UnusedFileScopedDecls; 2730 for (unsigned i=0, e = SemaRef.UnusedFileScopedDecls.size(); i !=e; ++i) 2731 AddDeclRef(SemaRef.UnusedFileScopedDecls[i], UnusedFileScopedDecls); 2732 2733 RecordData WeakUndeclaredIdentifiers; 2734 if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { 2735 WeakUndeclaredIdentifiers.push_back( 2736 SemaRef.WeakUndeclaredIdentifiers.size()); 2737 for (llvm::DenseMap<IdentifierInfo*,Sema::WeakInfo>::iterator 2738 I = SemaRef.WeakUndeclaredIdentifiers.begin(), 2739 E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { 2740 AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); 2741 AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); 2742 AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); 2743 WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); 2744 } 2745 } 2746 2747 // Build a record containing all of the locally-scoped external 2748 // declarations in this header file. Generally, this record will be 2749 // empty. 2750 RecordData LocallyScopedExternalDecls; 2751 // FIXME: This is filling in the AST file in densemap order which is 2752 // nondeterminstic! 2753 for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator 2754 TD = SemaRef.LocallyScopedExternalDecls.begin(), 2755 TDEnd = SemaRef.LocallyScopedExternalDecls.end(); 2756 TD != TDEnd; ++TD) 2757 AddDeclRef(TD->second, LocallyScopedExternalDecls); 2758 2759 // Build a record containing all of the ext_vector declarations. 2760 RecordData ExtVectorDecls; 2761 for (unsigned I = 0, N = SemaRef.ExtVectorDecls.size(); I != N; ++I) 2762 AddDeclRef(SemaRef.ExtVectorDecls[I], ExtVectorDecls); 2763 2764 // Build a record containing all of the VTable uses information. 2765 RecordData VTableUses; 2766 if (!SemaRef.VTableUses.empty()) { 2767 VTableUses.push_back(SemaRef.VTableUses.size()); 2768 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 2769 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 2770 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 2771 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 2772 } 2773 } 2774 2775 // Build a record containing all of dynamic classes declarations. 2776 RecordData DynamicClasses; 2777 for (unsigned I = 0, N = SemaRef.DynamicClasses.size(); I != N; ++I) 2778 AddDeclRef(SemaRef.DynamicClasses[I], DynamicClasses); 2779 2780 // Build a record containing all of pending implicit instantiations. 2781 RecordData PendingInstantiations; 2782 for (std::deque<Sema::PendingImplicitInstantiation>::iterator 2783 I = SemaRef.PendingInstantiations.begin(), 2784 N = SemaRef.PendingInstantiations.end(); I != N; ++I) { 2785 AddDeclRef(I->first, PendingInstantiations); 2786 AddSourceLocation(I->second, PendingInstantiations); 2787 } 2788 assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 2789 "There are local ones at end of translation unit!"); 2790 2791 // Build a record containing some declaration references. 2792 RecordData SemaDeclRefs; 2793 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { 2794 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 2795 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 2796 } 2797 2798 RecordData CUDASpecialDeclRefs; 2799 if (Context.getcudaConfigureCallDecl()) { 2800 AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); 2801 } 2802 2803 // Write the remaining AST contents. 2804 RecordData Record; 2805 Stream.EnterSubblock(AST_BLOCK_ID, 5); 2806 WriteMetadata(Context, isysroot, OutputFile); 2807 WriteLanguageOptions(Context.getLangOptions()); 2808 if (StatCalls && !isysroot) 2809 WriteStatCache(*StatCalls); 2810 WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); 2811 // Write the record of special types. 2812 Record.clear(); 2813 2814 AddTypeRef(Context.getBuiltinVaListType(), Record); 2815 AddTypeRef(Context.getObjCIdType(), Record); 2816 AddTypeRef(Context.getObjCSelType(), Record); 2817 AddTypeRef(Context.getObjCProtoType(), Record); 2818 AddTypeRef(Context.getObjCClassType(), Record); 2819 AddTypeRef(Context.getRawCFConstantStringType(), Record); 2820 AddTypeRef(Context.getRawObjCFastEnumerationStateType(), Record); 2821 AddTypeRef(Context.getFILEType(), Record); 2822 AddTypeRef(Context.getjmp_bufType(), Record); 2823 AddTypeRef(Context.getsigjmp_bufType(), Record); 2824 AddTypeRef(Context.ObjCIdRedefinitionType, Record); 2825 AddTypeRef(Context.ObjCClassRedefinitionType, Record); 2826 AddTypeRef(Context.getRawBlockdescriptorType(), Record); 2827 AddTypeRef(Context.getRawBlockdescriptorExtendedType(), Record); 2828 AddTypeRef(Context.ObjCSelRedefinitionType, Record); 2829 AddTypeRef(Context.getRawNSConstantStringType(), Record); 2830 Record.push_back(Context.isInt128Installed()); 2831 AddTypeRef(Context.AutoDeductTy, Record); 2832 AddTypeRef(Context.AutoRRefDeductTy, Record); 2833 Stream.EmitRecord(SPECIAL_TYPES, Record); 2834 2835 // Keep writing types and declarations until all types and 2836 // declarations have been written. 2837 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, 3); 2838 WriteDeclsBlockAbbrevs(); 2839 while (!DeclTypesToEmit.empty()) { 2840 DeclOrType DOT = DeclTypesToEmit.front(); 2841 DeclTypesToEmit.pop(); 2842 if (DOT.isType()) 2843 WriteType(DOT.getType()); 2844 else 2845 WriteDecl(Context, DOT.getDecl()); 2846 } 2847 Stream.ExitBlock(); 2848 2849 WritePreprocessor(PP); 2850 WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot); 2851 WriteSelectors(SemaRef); 2852 WriteReferencedSelectorsPool(SemaRef); 2853 WriteIdentifierTable(PP); 2854 WriteFPPragmaOptions(SemaRef.getFPOptions()); 2855 WriteOpenCLExtensions(SemaRef); 2856 2857 WriteTypeDeclOffsets(); 2858 WritePragmaDiagnosticMappings(Context.getDiagnostics()); 2859 2860 WriteCXXBaseSpecifiersOffsets(); 2861 2862 // Write the record containing external, unnamed definitions. 2863 if (!ExternalDefinitions.empty()) 2864 Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions); 2865 2866 // Write the record containing tentative definitions. 2867 if (!TentativeDefinitions.empty()) 2868 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 2869 2870 // Write the record containing unused file scoped decls. 2871 if (!UnusedFileScopedDecls.empty()) 2872 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 2873 2874 // Write the record containing weak undeclared identifiers. 2875 if (!WeakUndeclaredIdentifiers.empty()) 2876 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 2877 WeakUndeclaredIdentifiers); 2878 2879 // Write the record containing locally-scoped external definitions. 2880 if (!LocallyScopedExternalDecls.empty()) 2881 Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS, 2882 LocallyScopedExternalDecls); 2883 2884 // Write the record containing ext_vector type names. 2885 if (!ExtVectorDecls.empty()) 2886 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 2887 2888 // Write the record containing VTable uses information. 2889 if (!VTableUses.empty()) 2890 Stream.EmitRecord(VTABLE_USES, VTableUses); 2891 2892 // Write the record containing dynamic classes declarations. 2893 if (!DynamicClasses.empty()) 2894 Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); 2895 2896 // Write the record containing pending implicit instantiations. 2897 if (!PendingInstantiations.empty()) 2898 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); 2899 2900 // Write the record containing declaration references of Sema. 2901 if (!SemaDeclRefs.empty()) 2902 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 2903 2904 // Write the record containing CUDA-specific declaration references. 2905 if (!CUDASpecialDeclRefs.empty()) 2906 Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); 2907 2908 // Some simple statistics 2909 Record.clear(); 2910 Record.push_back(NumStatements); 2911 Record.push_back(NumMacros); 2912 Record.push_back(NumLexicalDeclContexts); 2913 Record.push_back(NumVisibleDeclContexts); 2914 Stream.EmitRecord(STATISTICS, Record); 2915 Stream.ExitBlock(); 2916} 2917 2918void ASTWriter::WriteASTChain(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2919 const char *isysroot) { 2920 using namespace llvm; 2921 2922 ASTContext &Context = SemaRef.Context; 2923 Preprocessor &PP = SemaRef.PP; 2924 2925 RecordData Record; 2926 Stream.EnterSubblock(AST_BLOCK_ID, 5); 2927 WriteMetadata(Context, isysroot, ""); 2928 if (StatCalls && !isysroot) 2929 WriteStatCache(*StatCalls); 2930 // FIXME: Source manager block should only write new stuff, which could be 2931 // done by tracking the largest ID in the chain 2932 WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); 2933 2934 // The special types are in the chained PCH. 2935 2936 // We don't start with the translation unit, but with its decls that 2937 // don't come from the chained PCH. 2938 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 2939 llvm::SmallVector<KindDeclIDPair, 64> NewGlobalDecls; 2940 for (DeclContext::decl_iterator I = TU->noload_decls_begin(), 2941 E = TU->noload_decls_end(); 2942 I != E; ++I) { 2943 if ((*I)->getPCHLevel() == 0) 2944 NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I))); 2945 else if ((*I)->isChangedSinceDeserialization()) 2946 (void)GetDeclRef(*I); // Make sure it's written, but don't record it. 2947 } 2948 // We also need to write a lexical updates block for the TU. 2949 llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); 2950 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); 2951 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 2952 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); 2953 Record.clear(); 2954 Record.push_back(TU_UPDATE_LEXICAL); 2955 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, 2956 reinterpret_cast<const char*>(NewGlobalDecls.data()), 2957 NewGlobalDecls.size() * sizeof(KindDeclIDPair)); 2958 // And a visible updates block for the DeclContexts. 2959 Abv = new llvm::BitCodeAbbrev(); 2960 Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); 2961 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 2962 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32)); 2963 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 2964 UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv); 2965 WriteDeclContextVisibleUpdate(TU); 2966 2967 // Build a record containing all of the new tentative definitions in this 2968 // file, in TentativeDefinitions order. 2969 RecordData TentativeDefinitions; 2970 for (unsigned i = 0, e = SemaRef.TentativeDefinitions.size(); i != e; ++i) { 2971 if (SemaRef.TentativeDefinitions[i]->getPCHLevel() == 0) 2972 AddDeclRef(SemaRef.TentativeDefinitions[i], TentativeDefinitions); 2973 } 2974 2975 // Build a record containing all of the file scoped decls in this file. 2976 RecordData UnusedFileScopedDecls; 2977 for (unsigned i=0, e = SemaRef.UnusedFileScopedDecls.size(); i !=e; ++i) { 2978 if (SemaRef.UnusedFileScopedDecls[i]->getPCHLevel() == 0) 2979 AddDeclRef(SemaRef.UnusedFileScopedDecls[i], UnusedFileScopedDecls); 2980 } 2981 2982 // We write the entire table, overwriting the tables from the chain. 2983 RecordData WeakUndeclaredIdentifiers; 2984 if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { 2985 WeakUndeclaredIdentifiers.push_back( 2986 SemaRef.WeakUndeclaredIdentifiers.size()); 2987 for (llvm::DenseMap<IdentifierInfo*,Sema::WeakInfo>::iterator 2988 I = SemaRef.WeakUndeclaredIdentifiers.begin(), 2989 E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { 2990 AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); 2991 AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); 2992 AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); 2993 WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); 2994 } 2995 } 2996 2997 // Build a record containing all of the locally-scoped external 2998 // declarations in this header file. Generally, this record will be 2999 // empty. 3000 RecordData LocallyScopedExternalDecls; 3001 // FIXME: This is filling in the AST file in densemap order which is 3002 // nondeterminstic! 3003 for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator 3004 TD = SemaRef.LocallyScopedExternalDecls.begin(), 3005 TDEnd = SemaRef.LocallyScopedExternalDecls.end(); 3006 TD != TDEnd; ++TD) { 3007 if (TD->second->getPCHLevel() == 0) 3008 AddDeclRef(TD->second, LocallyScopedExternalDecls); 3009 } 3010 3011 // Build a record containing all of the ext_vector declarations. 3012 RecordData ExtVectorDecls; 3013 for (unsigned I = 0, N = SemaRef.ExtVectorDecls.size(); I != N; ++I) { 3014 if (SemaRef.ExtVectorDecls[I]->getPCHLevel() == 0) 3015 AddDeclRef(SemaRef.ExtVectorDecls[I], ExtVectorDecls); 3016 } 3017 3018 // Build a record containing all of the VTable uses information. 3019 // We write everything here, because it's too hard to determine whether 3020 // a use is new to this part. 3021 RecordData VTableUses; 3022 if (!SemaRef.VTableUses.empty()) { 3023 VTableUses.push_back(SemaRef.VTableUses.size()); 3024 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 3025 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 3026 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 3027 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 3028 } 3029 } 3030 3031 // Build a record containing all of dynamic classes declarations. 3032 RecordData DynamicClasses; 3033 for (unsigned I = 0, N = SemaRef.DynamicClasses.size(); I != N; ++I) 3034 if (SemaRef.DynamicClasses[I]->getPCHLevel() == 0) 3035 AddDeclRef(SemaRef.DynamicClasses[I], DynamicClasses); 3036 3037 // Build a record containing all of pending implicit instantiations. 3038 RecordData PendingInstantiations; 3039 for (std::deque<Sema::PendingImplicitInstantiation>::iterator 3040 I = SemaRef.PendingInstantiations.begin(), 3041 N = SemaRef.PendingInstantiations.end(); I != N; ++I) { 3042 AddDeclRef(I->first, PendingInstantiations); 3043 AddSourceLocation(I->second, PendingInstantiations); 3044 } 3045 assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 3046 "There are local ones at end of translation unit!"); 3047 3048 // Build a record containing some declaration references. 3049 // It's not worth the effort to avoid duplication here. 3050 RecordData SemaDeclRefs; 3051 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { 3052 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 3053 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 3054 } 3055 3056 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, 3); 3057 WriteDeclsBlockAbbrevs(); 3058 for (DeclsToRewriteTy::iterator 3059 I = DeclsToRewrite.begin(), E = DeclsToRewrite.end(); I != E; ++I) 3060 DeclTypesToEmit.push(const_cast<Decl*>(*I)); 3061 while (!DeclTypesToEmit.empty()) { 3062 DeclOrType DOT = DeclTypesToEmit.front(); 3063 DeclTypesToEmit.pop(); 3064 if (DOT.isType()) 3065 WriteType(DOT.getType()); 3066 else 3067 WriteDecl(Context, DOT.getDecl()); 3068 } 3069 Stream.ExitBlock(); 3070 3071 WritePreprocessor(PP); 3072 WriteSelectors(SemaRef); 3073 WriteReferencedSelectorsPool(SemaRef); 3074 WriteIdentifierTable(PP); 3075 WriteFPPragmaOptions(SemaRef.getFPOptions()); 3076 WriteOpenCLExtensions(SemaRef); 3077 3078 WriteTypeDeclOffsets(); 3079 // FIXME: For chained PCH only write the new mappings (we currently 3080 // write all of them again). 3081 WritePragmaDiagnosticMappings(Context.getDiagnostics()); 3082 3083 WriteCXXBaseSpecifiersOffsets(); 3084 3085 /// Build a record containing first declarations from a chained PCH and the 3086 /// most recent declarations in this AST that they point to. 3087 RecordData FirstLatestDeclIDs; 3088 for (FirstLatestDeclMap::iterator 3089 I = FirstLatestDecls.begin(), E = FirstLatestDecls.end(); I != E; ++I) { 3090 assert(I->first->getPCHLevel() > I->second->getPCHLevel() && 3091 "Expected first & second to be in different PCHs"); 3092 AddDeclRef(I->first, FirstLatestDeclIDs); 3093 AddDeclRef(I->second, FirstLatestDeclIDs); 3094 } 3095 if (!FirstLatestDeclIDs.empty()) 3096 Stream.EmitRecord(REDECLS_UPDATE_LATEST, FirstLatestDeclIDs); 3097 3098 // Write the record containing external, unnamed definitions. 3099 if (!ExternalDefinitions.empty()) 3100 Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions); 3101 3102 // Write the record containing tentative definitions. 3103 if (!TentativeDefinitions.empty()) 3104 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 3105 3106 // Write the record containing unused file scoped decls. 3107 if (!UnusedFileScopedDecls.empty()) 3108 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 3109 3110 // Write the record containing weak undeclared identifiers. 3111 if (!WeakUndeclaredIdentifiers.empty()) 3112 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 3113 WeakUndeclaredIdentifiers); 3114 3115 // Write the record containing locally-scoped external definitions. 3116 if (!LocallyScopedExternalDecls.empty()) 3117 Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS, 3118 LocallyScopedExternalDecls); 3119 3120 // Write the record containing ext_vector type names. 3121 if (!ExtVectorDecls.empty()) 3122 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 3123 3124 // Write the record containing VTable uses information. 3125 if (!VTableUses.empty()) 3126 Stream.EmitRecord(VTABLE_USES, VTableUses); 3127 3128 // Write the record containing dynamic classes declarations. 3129 if (!DynamicClasses.empty()) 3130 Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); 3131 3132 // Write the record containing pending implicit instantiations. 3133 if (!PendingInstantiations.empty()) 3134 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); 3135 3136 // Write the record containing declaration references of Sema. 3137 if (!SemaDeclRefs.empty()) 3138 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 3139 3140 // Write the updates to DeclContexts. 3141 for (llvm::SmallPtrSet<const DeclContext *, 16>::iterator 3142 I = UpdatedDeclContexts.begin(), 3143 E = UpdatedDeclContexts.end(); 3144 I != E; ++I) 3145 WriteDeclContextVisibleUpdate(*I); 3146 3147 WriteDeclUpdatesBlocks(); 3148 3149 Record.clear(); 3150 Record.push_back(NumStatements); 3151 Record.push_back(NumMacros); 3152 Record.push_back(NumLexicalDeclContexts); 3153 Record.push_back(NumVisibleDeclContexts); 3154 WriteDeclReplacementsBlock(); 3155 Stream.EmitRecord(STATISTICS, Record); 3156 Stream.ExitBlock(); 3157} 3158 3159void ASTWriter::WriteDeclUpdatesBlocks() { 3160 if (DeclUpdates.empty()) 3161 return; 3162 3163 RecordData OffsetsRecord; 3164 Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, 3); 3165 for (DeclUpdateMap::iterator 3166 I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { 3167 const Decl *D = I->first; 3168 UpdateRecord &URec = I->second; 3169 3170 if (DeclsToRewrite.count(D)) 3171 continue; // The decl will be written completely,no need to store updates. 3172 3173 uint64_t Offset = Stream.GetCurrentBitNo(); 3174 Stream.EmitRecord(DECL_UPDATES, URec); 3175 3176 OffsetsRecord.push_back(GetDeclRef(D)); 3177 OffsetsRecord.push_back(Offset); 3178 } 3179 Stream.ExitBlock(); 3180 Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord); 3181} 3182 3183void ASTWriter::WriteDeclReplacementsBlock() { 3184 if (ReplacedDecls.empty()) 3185 return; 3186 3187 RecordData Record; 3188 for (llvm::SmallVector<std::pair<DeclID, uint64_t>, 16>::iterator 3189 I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { 3190 Record.push_back(I->first); 3191 Record.push_back(I->second); 3192 } 3193 Stream.EmitRecord(DECL_REPLACEMENTS, Record); 3194} 3195 3196void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { 3197 Record.push_back(Loc.getRawEncoding()); 3198} 3199 3200void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { 3201 AddSourceLocation(Range.getBegin(), Record); 3202 AddSourceLocation(Range.getEnd(), Record); 3203} 3204 3205void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) { 3206 Record.push_back(Value.getBitWidth()); 3207 const uint64_t *Words = Value.getRawData(); 3208 Record.append(Words, Words + Value.getNumWords()); 3209} 3210 3211void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) { 3212 Record.push_back(Value.isUnsigned()); 3213 AddAPInt(Value, Record); 3214} 3215 3216void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) { 3217 AddAPInt(Value.bitcastToAPInt(), Record); 3218} 3219 3220void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { 3221 Record.push_back(getIdentifierRef(II)); 3222} 3223 3224IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { 3225 if (II == 0) 3226 return 0; 3227 3228 IdentID &ID = IdentifierIDs[II]; 3229 if (ID == 0) 3230 ID = NextIdentID++; 3231 return ID; 3232} 3233 3234MacroID ASTWriter::getMacroDefinitionID(MacroDefinition *MD) { 3235 if (MD == 0) 3236 return 0; 3237 3238 MacroID &ID = MacroDefinitions[MD]; 3239 if (ID == 0) 3240 ID = NextMacroID++; 3241 return ID; 3242} 3243 3244void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) { 3245 Record.push_back(getSelectorRef(SelRef)); 3246} 3247 3248SelectorID ASTWriter::getSelectorRef(Selector Sel) { 3249 if (Sel.getAsOpaquePtr() == 0) { 3250 return 0; 3251 } 3252 3253 SelectorID &SID = SelectorIDs[Sel]; 3254 if (SID == 0 && Chain) { 3255 // This might trigger a ReadSelector callback, which will set the ID for 3256 // this selector. 3257 Chain->LoadSelector(Sel); 3258 } 3259 if (SID == 0) { 3260 SID = NextSelectorID++; 3261 } 3262 return SID; 3263} 3264 3265void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) { 3266 AddDeclRef(Temp->getDestructor(), Record); 3267} 3268 3269void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases, 3270 CXXBaseSpecifier const *BasesEnd, 3271 RecordDataImpl &Record) { 3272 assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded"); 3273 CXXBaseSpecifiersToWrite.push_back( 3274 QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID, 3275 Bases, BasesEnd)); 3276 Record.push_back(NextCXXBaseSpecifiersID++); 3277} 3278 3279void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, 3280 const TemplateArgumentLocInfo &Arg, 3281 RecordDataImpl &Record) { 3282 switch (Kind) { 3283 case TemplateArgument::Expression: 3284 AddStmt(Arg.getAsExpr()); 3285 break; 3286 case TemplateArgument::Type: 3287 AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record); 3288 break; 3289 case TemplateArgument::Template: 3290 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); 3291 AddSourceLocation(Arg.getTemplateNameLoc(), Record); 3292 break; 3293 case TemplateArgument::TemplateExpansion: 3294 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); 3295 AddSourceLocation(Arg.getTemplateNameLoc(), Record); 3296 AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record); 3297 break; 3298 case TemplateArgument::Null: 3299 case TemplateArgument::Integral: 3300 case TemplateArgument::Declaration: 3301 case TemplateArgument::Pack: 3302 break; 3303 } 3304} 3305 3306void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, 3307 RecordDataImpl &Record) { 3308 AddTemplateArgument(Arg.getArgument(), Record); 3309 3310 if (Arg.getArgument().getKind() == TemplateArgument::Expression) { 3311 bool InfoHasSameExpr 3312 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); 3313 Record.push_back(InfoHasSameExpr); 3314 if (InfoHasSameExpr) 3315 return; // Avoid storing the same expr twice. 3316 } 3317 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(), 3318 Record); 3319} 3320 3321void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, 3322 RecordDataImpl &Record) { 3323 if (TInfo == 0) { 3324 AddTypeRef(QualType(), Record); 3325 return; 3326 } 3327 3328 AddTypeLoc(TInfo->getTypeLoc(), Record); 3329} 3330 3331void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) { 3332 AddTypeRef(TL.getType(), Record); 3333 3334 TypeLocWriter TLW(*this, Record); 3335 for (; !TL.isNull(); TL = TL.getNextTypeLoc()) 3336 TLW.Visit(TL); 3337} 3338 3339void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { 3340 Record.push_back(GetOrCreateTypeID(T)); 3341} 3342 3343TypeID ASTWriter::GetOrCreateTypeID(QualType T) { 3344 return MakeTypeID(T, 3345 std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this)); 3346} 3347 3348TypeID ASTWriter::getTypeID(QualType T) const { 3349 return MakeTypeID(T, 3350 std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this)); 3351} 3352 3353TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) { 3354 if (T.isNull()) 3355 return TypeIdx(); 3356 assert(!T.getLocalFastQualifiers()); 3357 3358 TypeIdx &Idx = TypeIdxs[T]; 3359 if (Idx.getIndex() == 0) { 3360 // We haven't seen this type before. Assign it a new ID and put it 3361 // into the queue of types to emit. 3362 Idx = TypeIdx(NextTypeID++); 3363 DeclTypesToEmit.push(T); 3364 } 3365 return Idx; 3366} 3367 3368TypeIdx ASTWriter::getTypeIdx(QualType T) const { 3369 if (T.isNull()) 3370 return TypeIdx(); 3371 assert(!T.getLocalFastQualifiers()); 3372 3373 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3374 assert(I != TypeIdxs.end() && "Type not emitted!"); 3375 return I->second; 3376} 3377 3378void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { 3379 Record.push_back(GetDeclRef(D)); 3380} 3381 3382DeclID ASTWriter::GetDeclRef(const Decl *D) { 3383 if (D == 0) { 3384 return 0; 3385 } 3386 assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer"); 3387 DeclID &ID = DeclIDs[D]; 3388 if (ID == 0) { 3389 // We haven't seen this declaration before. Give it a new ID and 3390 // enqueue it in the list of declarations to emit. 3391 ID = NextDeclID++; 3392 DeclTypesToEmit.push(const_cast<Decl *>(D)); 3393 } else if (ID < FirstDeclID && D->isChangedSinceDeserialization()) { 3394 // We don't add it to the replacement collection here, because we don't 3395 // have the offset yet. 3396 DeclTypesToEmit.push(const_cast<Decl *>(D)); 3397 // Reset the flag, so that we don't add this decl multiple times. 3398 const_cast<Decl *>(D)->setChangedSinceDeserialization(false); 3399 } 3400 3401 return ID; 3402} 3403 3404DeclID ASTWriter::getDeclID(const Decl *D) { 3405 if (D == 0) 3406 return 0; 3407 3408 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); 3409 return DeclIDs[D]; 3410} 3411 3412void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) { 3413 // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. 3414 Record.push_back(Name.getNameKind()); 3415 switch (Name.getNameKind()) { 3416 case DeclarationName::Identifier: 3417 AddIdentifierRef(Name.getAsIdentifierInfo(), Record); 3418 break; 3419 3420 case DeclarationName::ObjCZeroArgSelector: 3421 case DeclarationName::ObjCOneArgSelector: 3422 case DeclarationName::ObjCMultiArgSelector: 3423 AddSelectorRef(Name.getObjCSelector(), Record); 3424 break; 3425 3426 case DeclarationName::CXXConstructorName: 3427 case DeclarationName::CXXDestructorName: 3428 case DeclarationName::CXXConversionFunctionName: 3429 AddTypeRef(Name.getCXXNameType(), Record); 3430 break; 3431 3432 case DeclarationName::CXXOperatorName: 3433 Record.push_back(Name.getCXXOverloadedOperator()); 3434 break; 3435 3436 case DeclarationName::CXXLiteralOperatorName: 3437 AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record); 3438 break; 3439 3440 case DeclarationName::CXXUsingDirective: 3441 // No extra data to emit 3442 break; 3443 } 3444} 3445 3446void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, 3447 DeclarationName Name, RecordDataImpl &Record) { 3448 switch (Name.getNameKind()) { 3449 case DeclarationName::CXXConstructorName: 3450 case DeclarationName::CXXDestructorName: 3451 case DeclarationName::CXXConversionFunctionName: 3452 AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record); 3453 break; 3454 3455 case DeclarationName::CXXOperatorName: 3456 AddSourceLocation( 3457 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc), 3458 Record); 3459 AddSourceLocation( 3460 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc), 3461 Record); 3462 break; 3463 3464 case DeclarationName::CXXLiteralOperatorName: 3465 AddSourceLocation( 3466 SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc), 3467 Record); 3468 break; 3469 3470 case DeclarationName::Identifier: 3471 case DeclarationName::ObjCZeroArgSelector: 3472 case DeclarationName::ObjCOneArgSelector: 3473 case DeclarationName::ObjCMultiArgSelector: 3474 case DeclarationName::CXXUsingDirective: 3475 break; 3476 } 3477} 3478 3479void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 3480 RecordDataImpl &Record) { 3481 AddDeclarationName(NameInfo.getName(), Record); 3482 AddSourceLocation(NameInfo.getLoc(), Record); 3483 AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record); 3484} 3485 3486void ASTWriter::AddQualifierInfo(const QualifierInfo &Info, 3487 RecordDataImpl &Record) { 3488 AddNestedNameSpecifierLoc(Info.QualifierLoc, Record); 3489 Record.push_back(Info.NumTemplParamLists); 3490 for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i) 3491 AddTemplateParameterList(Info.TemplParamLists[i], Record); 3492} 3493 3494void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS, 3495 RecordDataImpl &Record) { 3496 // Nested name specifiers usually aren't too long. I think that 8 would 3497 // typically accommodate the vast majority. 3498 llvm::SmallVector<NestedNameSpecifier *, 8> NestedNames; 3499 3500 // Push each of the NNS's onto a stack for serialization in reverse order. 3501 while (NNS) { 3502 NestedNames.push_back(NNS); 3503 NNS = NNS->getPrefix(); 3504 } 3505 3506 Record.push_back(NestedNames.size()); 3507 while(!NestedNames.empty()) { 3508 NNS = NestedNames.pop_back_val(); 3509 NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); 3510 Record.push_back(Kind); 3511 switch (Kind) { 3512 case NestedNameSpecifier::Identifier: 3513 AddIdentifierRef(NNS->getAsIdentifier(), Record); 3514 break; 3515 3516 case NestedNameSpecifier::Namespace: 3517 AddDeclRef(NNS->getAsNamespace(), Record); 3518 break; 3519 3520 case NestedNameSpecifier::NamespaceAlias: 3521 AddDeclRef(NNS->getAsNamespaceAlias(), Record); 3522 break; 3523 3524 case NestedNameSpecifier::TypeSpec: 3525 case NestedNameSpecifier::TypeSpecWithTemplate: 3526 AddTypeRef(QualType(NNS->getAsType(), 0), Record); 3527 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 3528 break; 3529 3530 case NestedNameSpecifier::Global: 3531 // Don't need to write an associated value. 3532 break; 3533 } 3534 } 3535} 3536 3537void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 3538 RecordDataImpl &Record) { 3539 // Nested name specifiers usually aren't too long. I think that 8 would 3540 // typically accommodate the vast majority. 3541 llvm::SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 3542 3543 // Push each of the nested-name-specifiers's onto a stack for 3544 // serialization in reverse order. 3545 while (NNS) { 3546 NestedNames.push_back(NNS); 3547 NNS = NNS.getPrefix(); 3548 } 3549 3550 Record.push_back(NestedNames.size()); 3551 while(!NestedNames.empty()) { 3552 NNS = NestedNames.pop_back_val(); 3553 NestedNameSpecifier::SpecifierKind Kind 3554 = NNS.getNestedNameSpecifier()->getKind(); 3555 Record.push_back(Kind); 3556 switch (Kind) { 3557 case NestedNameSpecifier::Identifier: 3558 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record); 3559 AddSourceRange(NNS.getLocalSourceRange(), Record); 3560 break; 3561 3562 case NestedNameSpecifier::Namespace: 3563 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record); 3564 AddSourceRange(NNS.getLocalSourceRange(), Record); 3565 break; 3566 3567 case NestedNameSpecifier::NamespaceAlias: 3568 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record); 3569 AddSourceRange(NNS.getLocalSourceRange(), Record); 3570 break; 3571 3572 case NestedNameSpecifier::TypeSpec: 3573 case NestedNameSpecifier::TypeSpecWithTemplate: 3574 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 3575 AddTypeLoc(NNS.getTypeLoc(), Record); 3576 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); 3577 break; 3578 3579 case NestedNameSpecifier::Global: 3580 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); 3581 break; 3582 } 3583 } 3584} 3585 3586void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) { 3587 TemplateName::NameKind Kind = Name.getKind(); 3588 Record.push_back(Kind); 3589 switch (Kind) { 3590 case TemplateName::Template: 3591 AddDeclRef(Name.getAsTemplateDecl(), Record); 3592 break; 3593 3594 case TemplateName::OverloadedTemplate: { 3595 OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); 3596 Record.push_back(OvT->size()); 3597 for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end(); 3598 I != E; ++I) 3599 AddDeclRef(*I, Record); 3600 break; 3601 } 3602 3603 case TemplateName::QualifiedTemplate: { 3604 QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); 3605 AddNestedNameSpecifier(QualT->getQualifier(), Record); 3606 Record.push_back(QualT->hasTemplateKeyword()); 3607 AddDeclRef(QualT->getTemplateDecl(), Record); 3608 break; 3609 } 3610 3611 case TemplateName::DependentTemplate: { 3612 DependentTemplateName *DepT = Name.getAsDependentTemplateName(); 3613 AddNestedNameSpecifier(DepT->getQualifier(), Record); 3614 Record.push_back(DepT->isIdentifier()); 3615 if (DepT->isIdentifier()) 3616 AddIdentifierRef(DepT->getIdentifier(), Record); 3617 else 3618 Record.push_back(DepT->getOperator()); 3619 break; 3620 } 3621 3622 case TemplateName::SubstTemplateTemplateParmPack: { 3623 SubstTemplateTemplateParmPackStorage *SubstPack 3624 = Name.getAsSubstTemplateTemplateParmPack(); 3625 AddDeclRef(SubstPack->getParameterPack(), Record); 3626 AddTemplateArgument(SubstPack->getArgumentPack(), Record); 3627 break; 3628 } 3629 } 3630} 3631 3632void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, 3633 RecordDataImpl &Record) { 3634 Record.push_back(Arg.getKind()); 3635 switch (Arg.getKind()) { 3636 case TemplateArgument::Null: 3637 break; 3638 case TemplateArgument::Type: 3639 AddTypeRef(Arg.getAsType(), Record); 3640 break; 3641 case TemplateArgument::Declaration: 3642 AddDeclRef(Arg.getAsDecl(), Record); 3643 break; 3644 case TemplateArgument::Integral: 3645 AddAPSInt(*Arg.getAsIntegral(), Record); 3646 AddTypeRef(Arg.getIntegralType(), Record); 3647 break; 3648 case TemplateArgument::Template: 3649 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); 3650 break; 3651 case TemplateArgument::TemplateExpansion: 3652 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); 3653 if (llvm::Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions()) 3654 Record.push_back(*NumExpansions + 1); 3655 else 3656 Record.push_back(0); 3657 break; 3658 case TemplateArgument::Expression: 3659 AddStmt(Arg.getAsExpr()); 3660 break; 3661 case TemplateArgument::Pack: 3662 Record.push_back(Arg.pack_size()); 3663 for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); 3664 I != E; ++I) 3665 AddTemplateArgument(*I, Record); 3666 break; 3667 } 3668} 3669 3670void 3671ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams, 3672 RecordDataImpl &Record) { 3673 assert(TemplateParams && "No TemplateParams!"); 3674 AddSourceLocation(TemplateParams->getTemplateLoc(), Record); 3675 AddSourceLocation(TemplateParams->getLAngleLoc(), Record); 3676 AddSourceLocation(TemplateParams->getRAngleLoc(), Record); 3677 Record.push_back(TemplateParams->size()); 3678 for (TemplateParameterList::const_iterator 3679 P = TemplateParams->begin(), PEnd = TemplateParams->end(); 3680 P != PEnd; ++P) 3681 AddDeclRef(*P, Record); 3682} 3683 3684/// \brief Emit a template argument list. 3685void 3686ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs, 3687 RecordDataImpl &Record) { 3688 assert(TemplateArgs && "No TemplateArgs!"); 3689 Record.push_back(TemplateArgs->size()); 3690 for (int i=0, e = TemplateArgs->size(); i != e; ++i) 3691 AddTemplateArgument(TemplateArgs->get(i), Record); 3692} 3693 3694 3695void 3696ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordDataImpl &Record) { 3697 Record.push_back(Set.size()); 3698 for (UnresolvedSetImpl::const_iterator 3699 I = Set.begin(), E = Set.end(); I != E; ++I) { 3700 AddDeclRef(I.getDecl(), Record); 3701 Record.push_back(I.getAccess()); 3702 } 3703} 3704 3705void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, 3706 RecordDataImpl &Record) { 3707 Record.push_back(Base.isVirtual()); 3708 Record.push_back(Base.isBaseOfClass()); 3709 Record.push_back(Base.getAccessSpecifierAsWritten()); 3710 Record.push_back(Base.getInheritConstructors()); 3711 AddTypeSourceInfo(Base.getTypeSourceInfo(), Record); 3712 AddSourceRange(Base.getSourceRange(), Record); 3713 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() 3714 : SourceLocation(), 3715 Record); 3716} 3717 3718void ASTWriter::FlushCXXBaseSpecifiers() { 3719 RecordData Record; 3720 for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) { 3721 Record.clear(); 3722 3723 // Record the offset of this base-specifier set. 3724 unsigned Index = CXXBaseSpecifiersToWrite[I].ID - FirstCXXBaseSpecifiersID; 3725 if (Index == CXXBaseSpecifiersOffsets.size()) 3726 CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo()); 3727 else { 3728 if (Index > CXXBaseSpecifiersOffsets.size()) 3729 CXXBaseSpecifiersOffsets.resize(Index + 1); 3730 CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo(); 3731 } 3732 3733 const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases, 3734 *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd; 3735 Record.push_back(BEnd - B); 3736 for (; B != BEnd; ++B) 3737 AddCXXBaseSpecifier(*B, Record); 3738 Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record); 3739 3740 // Flush any expressions that were written as part of the base specifiers. 3741 FlushStmts(); 3742 } 3743 3744 CXXBaseSpecifiersToWrite.clear(); 3745} 3746 3747void ASTWriter::AddCXXCtorInitializers( 3748 const CXXCtorInitializer * const *CtorInitializers, 3749 unsigned NumCtorInitializers, 3750 RecordDataImpl &Record) { 3751 Record.push_back(NumCtorInitializers); 3752 for (unsigned i=0; i != NumCtorInitializers; ++i) { 3753 const CXXCtorInitializer *Init = CtorInitializers[i]; 3754 3755 Record.push_back(Init->isBaseInitializer()); 3756 if (Init->isBaseInitializer()) { 3757 AddTypeSourceInfo(Init->getBaseClassInfo(), Record); 3758 Record.push_back(Init->isBaseVirtual()); 3759 } else { 3760 Record.push_back(Init->isIndirectMemberInitializer()); 3761 if (Init->isIndirectMemberInitializer()) 3762 AddDeclRef(Init->getIndirectMember(), Record); 3763 else 3764 AddDeclRef(Init->getMember(), Record); 3765 } 3766 3767 AddSourceLocation(Init->getMemberLocation(), Record); 3768 AddStmt(Init->getInit()); 3769 AddSourceLocation(Init->getLParenLoc(), Record); 3770 AddSourceLocation(Init->getRParenLoc(), Record); 3771 Record.push_back(Init->isWritten()); 3772 if (Init->isWritten()) { 3773 Record.push_back(Init->getSourceOrder()); 3774 } else { 3775 Record.push_back(Init->getNumArrayIndices()); 3776 for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i) 3777 AddDeclRef(Init->getArrayIndex(i), Record); 3778 } 3779 } 3780} 3781 3782void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) { 3783 assert(D->DefinitionData); 3784 struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData; 3785 Record.push_back(Data.UserDeclaredConstructor); 3786 Record.push_back(Data.UserDeclaredCopyConstructor); 3787 Record.push_back(Data.UserDeclaredCopyAssignment); 3788 Record.push_back(Data.UserDeclaredDestructor); 3789 Record.push_back(Data.Aggregate); 3790 Record.push_back(Data.PlainOldData); 3791 Record.push_back(Data.Empty); 3792 Record.push_back(Data.Polymorphic); 3793 Record.push_back(Data.Abstract); 3794 Record.push_back(Data.HasTrivialConstructor); 3795 Record.push_back(Data.HasConstExprNonCopyMoveConstructor); 3796 Record.push_back(Data.HasTrivialCopyConstructor); 3797 Record.push_back(Data.HasTrivialMoveConstructor); 3798 Record.push_back(Data.HasTrivialCopyAssignment); 3799 Record.push_back(Data.HasTrivialMoveAssignment); 3800 Record.push_back(Data.HasTrivialDestructor); 3801 Record.push_back(Data.HasNonLiteralTypeFieldsOrBases); 3802 Record.push_back(Data.ComputedVisibleConversions); 3803 Record.push_back(Data.DeclaredDefaultConstructor); 3804 Record.push_back(Data.DeclaredCopyConstructor); 3805 Record.push_back(Data.DeclaredCopyAssignment); 3806 Record.push_back(Data.DeclaredDestructor); 3807 3808 Record.push_back(Data.NumBases); 3809 if (Data.NumBases > 0) 3810 AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases, 3811 Record); 3812 3813 // FIXME: Make VBases lazily computed when needed to avoid storing them. 3814 Record.push_back(Data.NumVBases); 3815 if (Data.NumVBases > 0) 3816 AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases, 3817 Record); 3818 3819 AddUnresolvedSet(Data.Conversions, Record); 3820 AddUnresolvedSet(Data.VisibleConversions, Record); 3821 // Data.Definition is the owning decl, no need to write it. 3822 AddDeclRef(Data.FirstFriend, Record); 3823} 3824 3825void ASTWriter::ReaderInitialized(ASTReader *Reader) { 3826 assert(Reader && "Cannot remove chain"); 3827 assert(!Chain && "Cannot replace chain"); 3828 assert(FirstDeclID == NextDeclID && 3829 FirstTypeID == NextTypeID && 3830 FirstIdentID == NextIdentID && 3831 FirstSelectorID == NextSelectorID && 3832 FirstMacroID == NextMacroID && 3833 FirstCXXBaseSpecifiersID == NextCXXBaseSpecifiersID && 3834 "Setting chain after writing has started."); 3835 Chain = Reader; 3836 3837 FirstDeclID += Chain->getTotalNumDecls(); 3838 FirstTypeID += Chain->getTotalNumTypes(); 3839 FirstIdentID += Chain->getTotalNumIdentifiers(); 3840 FirstSelectorID += Chain->getTotalNumSelectors(); 3841 FirstMacroID += Chain->getTotalNumMacroDefinitions(); 3842 FirstCXXBaseSpecifiersID += Chain->getTotalNumCXXBaseSpecifiers(); 3843 NextDeclID = FirstDeclID; 3844 NextTypeID = FirstTypeID; 3845 NextIdentID = FirstIdentID; 3846 NextSelectorID = FirstSelectorID; 3847 NextMacroID = FirstMacroID; 3848 NextCXXBaseSpecifiersID = FirstCXXBaseSpecifiersID; 3849} 3850 3851void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { 3852 IdentifierIDs[II] = ID; 3853 if (II->hasMacroDefinition()) 3854 DeserializedMacroNames.push_back(II); 3855} 3856 3857void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { 3858 // Always take the highest-numbered type index. This copes with an interesting 3859 // case for chained AST writing where we schedule writing the type and then, 3860 // later, deserialize the type from another AST. In this case, we want to 3861 // keep the higher-numbered entry so that we can properly write it out to 3862 // the AST file. 3863 TypeIdx &StoredIdx = TypeIdxs[T]; 3864 if (Idx.getIndex() >= StoredIdx.getIndex()) 3865 StoredIdx = Idx; 3866} 3867 3868void ASTWriter::DeclRead(DeclID ID, const Decl *D) { 3869 DeclIDs[D] = ID; 3870} 3871 3872void ASTWriter::SelectorRead(SelectorID ID, Selector S) { 3873 SelectorIDs[S] = ID; 3874} 3875 3876void ASTWriter::MacroDefinitionRead(serialization::MacroID ID, 3877 MacroDefinition *MD) { 3878 MacroDefinitions[MD] = ID; 3879} 3880 3881void ASTWriter::CompletedTagDefinition(const TagDecl *D) { 3882 assert(D->isDefinition()); 3883 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 3884 // We are interested when a PCH decl is modified. 3885 if (RD->getPCHLevel() > 0) { 3886 // A forward reference was mutated into a definition. Rewrite it. 3887 // FIXME: This happens during template instantiation, should we 3888 // have created a new definition decl instead ? 3889 RewriteDecl(RD); 3890 } 3891 3892 for (CXXRecordDecl::redecl_iterator 3893 I = RD->redecls_begin(), E = RD->redecls_end(); I != E; ++I) { 3894 CXXRecordDecl *Redecl = cast<CXXRecordDecl>(*I); 3895 if (Redecl == RD) 3896 continue; 3897 3898 // We are interested when a PCH decl is modified. 3899 if (Redecl->getPCHLevel() > 0) { 3900 UpdateRecord &Record = DeclUpdates[Redecl]; 3901 Record.push_back(UPD_CXX_SET_DEFINITIONDATA); 3902 assert(Redecl->DefinitionData); 3903 assert(Redecl->DefinitionData->Definition == D); 3904 AddDeclRef(D, Record); // the DefinitionDecl 3905 } 3906 } 3907 } 3908} 3909void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { 3910 // TU and namespaces are handled elsewhere. 3911 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC)) 3912 return; 3913 3914 if (!(D->getPCHLevel() == 0 && cast<Decl>(DC)->getPCHLevel() > 0)) 3915 return; // Not a source decl added to a DeclContext from PCH. 3916 3917 AddUpdatedDeclContext(DC); 3918} 3919 3920void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { 3921 assert(D->isImplicit()); 3922 if (!(D->getPCHLevel() == 0 && RD->getPCHLevel() > 0)) 3923 return; // Not a source member added to a class from PCH. 3924 if (!isa<CXXMethodDecl>(D)) 3925 return; // We are interested in lazily declared implicit methods. 3926 3927 // A decl coming from PCH was modified. 3928 assert(RD->isDefinition()); 3929 UpdateRecord &Record = DeclUpdates[RD]; 3930 Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER); 3931 AddDeclRef(D, Record); 3932} 3933 3934void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, 3935 const ClassTemplateSpecializationDecl *D) { 3936 // The specializations set is kept in the canonical template. 3937 TD = TD->getCanonicalDecl(); 3938 if (!(D->getPCHLevel() == 0 && TD->getPCHLevel() > 0)) 3939 return; // Not a source specialization added to a template from PCH. 3940 3941 UpdateRecord &Record = DeclUpdates[TD]; 3942 Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); 3943 AddDeclRef(D, Record); 3944} 3945 3946void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, 3947 const FunctionDecl *D) { 3948 // The specializations set is kept in the canonical template. 3949 TD = TD->getCanonicalDecl(); 3950 if (!(D->getPCHLevel() == 0 && TD->getPCHLevel() > 0)) 3951 return; // Not a source specialization added to a template from PCH. 3952 3953 UpdateRecord &Record = DeclUpdates[TD]; 3954 Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); 3955 AddDeclRef(D, Record); 3956} 3957 3958void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { 3959 if (D->getPCHLevel() == 0) 3960 return; // Declaration not imported from PCH. 3961 3962 // Implicit decl from a PCH was defined. 3963 // FIXME: Should implicit definition be a separate FunctionDecl? 3964 RewriteDecl(D); 3965} 3966 3967ASTSerializationListener::~ASTSerializationListener() { } 3968