ASTWriter.cpp revision 4bc8738d837e5d401235f99e55277338e20e3651
15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===--- ASTWriter.cpp - AST File Writer ----------------------------------===// 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The LLVM Compiler Infrastructure 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 52a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// This file is distributed under the University of Illinois Open Source 62a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// License. See LICENSE.TXT for details. 72a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// 82a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)//===----------------------------------------------------------------------===// 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file defines the ASTWriter class, which writes AST files. 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Serialization/ASTWriter.h" 155d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#include "ASTCommon.h" 167d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles)#include "clang/Sema/Sema.h" 173551c9c881056c480085172ff9840cab31610854Torne (Richard Coles)#include "clang/Sema/IdentifierResolver.h" 18f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)#include "clang/AST/ASTContext.h" 192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/AST/Decl.h" 205d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#include "clang/AST/DeclContextInternals.h" 21effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch#include "clang/AST/DeclTemplate.h" 222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/AST/DeclFriend.h" 235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/Expr.h" 245d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#include "clang/AST/ExprCXX.h" 255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/Type.h" 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/TypeLocVisitor.h" 275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Serialization/ASTReader.h" 285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/MacroInfo.h" 2923730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles)#include "clang/Lex/PreprocessingRecord.h" 302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Lex/Preprocessor.h" 312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Lex/HeaderSearch.h" 322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Basic/FileManager.h" 33e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch#include "clang/Basic/FileSystemStatCache.h" 3423730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles)#include "clang/Basic/OnDiskHashTable.h" 352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Basic/SourceManager.h" 367dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch#include "clang/Basic/SourceManagerInternals.h" 3703b57e008b61dfcb1fbad3aea950ae0e001748b0Torne (Richard Coles)#include "clang/Basic/TargetInfo.h" 382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Basic/Version.h" 3990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "clang/Basic/VersionTuple.h" 4090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/ADT/APFloat.h" 4190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/ADT/APInt.h" 4290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/ADT/StringExtras.h" 43effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch#include "llvm/Bitcode/BitstreamWriter.h" 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/FileSystem.h" 458bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)#include "llvm/Support/MemoryBuffer.h" 468bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)#include "llvm/Support/Path.h" 478bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)#include <algorithm> 488bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)#include <cstdio> 498bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)#include <string.h> 508bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)#include <utility> 518bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)using namespace clang; 528bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)using namespace clang::serialization; 53a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 54a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)template <typename T, typename Allocator> 55a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)static StringRef data(const std::vector<T, Allocator> &v) { 56a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) if (v.empty()) return StringRef(); 57a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) return StringRef(reinterpret_cast<const char*>(&v[0]), 58a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) sizeof(T) * v.size()); 59a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)} 60a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 61a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)template <typename T> 62a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)static StringRef data(const SmallVectorImpl<T> &v) { 638bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return StringRef(reinterpret_cast<const char*>(v.data()), 64a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) sizeof(T) * v.size()); 65a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)} 66a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 67a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)//===----------------------------------------------------------------------===// 68a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)// Type serialization 69a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)//===----------------------------------------------------------------------===// 70a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 71a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)namespace { 72a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) class ASTTypeWriter { 73a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) ASTWriter &Writer; 74a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) ASTWriter::RecordDataImpl &Record; 75a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 76a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) public: 77a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) /// \brief Type code that corresponds to the record generated. 78a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) TypeCode Code; 79a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 80a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) 81a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { } 82a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 83a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) void VisitArrayType(const ArrayType *T); 84a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) void VisitFunctionType(const FunctionType *T); 85a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) void VisitTagType(const TagType *T); 86a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 87a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)#define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); 88a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)#define ABSTRACT_TYPE(Class, Base) 89a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)#include "clang/AST/TypeNodes.def" 901320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci }; 911320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { 943551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) llvm_unreachable("Built-in types are never serialized"); 952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9603b57e008b61dfcb1fbad3aea950ae0e001748b0Torne (Richard Coles) 9723730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles)void ASTTypeWriter::VisitComplexType(const ComplexType *T) { 9890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) Writer.AddTypeRef(T->getElementType(), Record); 9946d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) Code = TYPE_COMPLEX; 1002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void ASTTypeWriter::VisitPointerType(const PointerType *T) { 1031320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Writer.AddTypeRef(T->getPointeeType(), Record); 1041320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Code = TYPE_POINTER; 1051320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 1061320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 1071320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccivoid ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { 1081320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Writer.AddTypeRef(T->getPointeeType(), Record); 1098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Code = TYPE_BLOCK_POINTER; 1108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 1118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 112a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { 113a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); 114a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Record.push_back(T->isSpelledAsLValue()); 115a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Code = TYPE_LVALUE_REFERENCE; 116a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)} 117a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 118a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { 119a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); 120a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Code = TYPE_RVALUE_REFERENCE; 121a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)} 122a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) 123a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles)void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { 124a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Writer.AddTypeRef(T->getPointeeType(), Record); 1255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Writer.AddTypeRef(QualType(T->getClass(), 0), Record); 1265c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu Code = TYPE_MEMBER_POINTER; 12768043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)} 1285d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) 1295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void ASTTypeWriter::VisitArrayType(const ArrayType *T) { 1302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Writer.AddTypeRef(T->getElementType(), Record); 131424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) Record.push_back(T->getSizeModifier()); // FIXME: stable values 1325d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values 1335d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)} 134c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1353551c9c881056c480085172ff9840cab31610854Torne (Richard Coles)void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { 1363551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) VisitArrayType(T); 1373551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) Writer.AddAPInt(T->getSize(), Record); 1383551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) Code = TYPE_CONSTANT_ARRAY; 13923730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles)} 14023730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles) 141effb81e5f8246d0db0270817048dc992db66e9fbBen Murdochvoid ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 14223730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles) VisitArrayType(T); 14323730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles) Code = TYPE_INCOMPLETE_ARRAY; 14423730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles)} 14523730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles) 146c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { 147c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) VisitArrayType(T); 1481e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) Writer.AddSourceLocation(T->getLBracketLoc(), Record); 149d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) Writer.AddSourceLocation(T->getRBracketLoc(), Record); 150d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) Writer.AddStmt(T->getSizeExpr()); 1512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Code = TYPE_VARIABLE_ARRAY; 1522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1533551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 1543551c9c881056c480085172ff9840cab31610854Torne (Richard Coles)void ASTTypeWriter::VisitVectorType(const VectorType *T) { 1552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Writer.AddTypeRef(T->getElementType(), Record); 15646d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) Record.push_back(T->getNumElements()); 15746d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) Record.push_back(T->getVectorKind()); 15846d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) Code = TYPE_VECTOR; 1592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { 1625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VisitVectorType(T); 163eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch Code = TYPE_EXT_VECTOR; 164eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 1652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void ASTTypeWriter::VisitFunctionType(const FunctionType *T) { 167cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) Writer.AddTypeRef(T->getResultType(), Record); 1682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) FunctionType::ExtInfo C = T->getExtInfo(); 1692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Record.push_back(C.getNoReturn()); 1705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Record.push_back(C.getHasRegParm()); 171a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Record.push_back(C.getRegParm()); 172a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) // FIXME: need to stabilize encoding of calling convention... 17358537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) Record.push_back(C.getCC()); 17458537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) Record.push_back(C.getProducesResult()); 17558537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)} 17658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) 17758537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 1785d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) VisitFunctionType(T); 1795d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) Code = TYPE_FUNCTION_NO_PROTO; 1805d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)} 1815d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) 1825d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VisitFunctionType(T); 1845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Record.push_back(T->getNumArgs()); 1855d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I) 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Writer.AddTypeRef(T->getArgType(I), Record); 1875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Record.push_back(T->isVariadic()); 18890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) Record.push_back(T->getTypeQuals()); 189a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Record.push_back(static_cast<unsigned>(T->getRefQualifier())); 1908bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Record.push_back(T->getExceptionSpecType()); 191a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) if (T->getExceptionSpecType() == EST_Dynamic) { 192a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Record.push_back(T->getNumExceptions()); 193a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) 1942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Writer.AddTypeRef(T->getExceptionType(I), Record); 1952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) { 1962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Writer.AddStmt(T->getNoexceptExpr()); 197424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 198424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) Code = TYPE_FUNCTION_PROTO; 1998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 2008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 2018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { 2028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Writer.AddDeclRef(T->getDecl(), Record); 2038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Code = TYPE_UNRESOLVED_USING; 2048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 2058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)void ASTTypeWriter::VisitTypedefType(const TypedefType *T) { 207eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch Writer.AddDeclRef(T->getDecl(), Record); 2088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); 2098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record); 2108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Code = TYPE_TYPEDEF; 2118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 2128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 2138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { 2148bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Writer.AddStmt(T->getUnderlyingExpr()); 2158bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) Code = TYPE_TYPEOF_EXPR; 216eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 2178bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 218eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdochvoid ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { 219eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch Writer.AddTypeRef(T->getUnderlyingType(), Record); 220eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch Code = TYPE_TYPEOF; 2218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 222eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 22346d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles)void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { 22446d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) Writer.AddStmt(T->getUnderlyingExpr()); 2251320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Code = TYPE_DECLTYPE; 2263551c9c881056c480085172ff9840cab31610854Torne (Richard Coles)} 2272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) { 2292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Writer.AddTypeRef(T->getBaseType(), Record); 2302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Writer.AddTypeRef(T->getUnderlyingType(), Record); 23103b57e008b61dfcb1fbad3aea950ae0e001748b0Torne (Richard Coles) Record.push_back(T->getUTTKind()); 23223730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles) Code = TYPE_UNARY_TRANSFORM; 23323730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles)} 2345f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) 2358bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)void ASTTypeWriter::VisitAutoType(const AutoType *T) { 236a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) Writer.AddTypeRef(T->getDeducedType(), Record); 2372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Code = TYPE_AUTO; 2382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 2392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24046d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles)void ASTTypeWriter::VisitTagType(const TagType *T) { 2412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Record.push_back(T->isDependentType()); 242f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) Writer.AddDeclRef(T->getDecl(), Record); 2435f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) assert(!T->isBeingDefined() && 2441e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) "Cannot serialize in the middle of a type definition"); 2451e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)} 246effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 247effb81e5f8246d0db0270817048dc992db66e9fbBen Murdochvoid ASTTypeWriter::VisitRecordType(const RecordType *T) { 248effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch VisitTagType(T); 2493551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) Code = TYPE_RECORD; 2505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 2515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void ASTTypeWriter::VisitEnumType(const EnumType *T) { 2535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VisitTagType(T); 2545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Code = TYPE_ENUM; 2555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 2565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 257void ASTTypeWriter::VisitAttributedType(const AttributedType *T) { 258 Writer.AddTypeRef(T->getModifiedType(), Record); 259 Writer.AddTypeRef(T->getEquivalentType(), Record); 260 Record.push_back(T->getAttrKind()); 261 Code = TYPE_ATTRIBUTED; 262} 263 264void 265ASTTypeWriter::VisitSubstTemplateTypeParmType( 266 const SubstTemplateTypeParmType *T) { 267 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); 268 Writer.AddTypeRef(T->getReplacementType(), Record); 269 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; 270} 271 272void 273ASTTypeWriter::VisitSubstTemplateTypeParmPackType( 274 const SubstTemplateTypeParmPackType *T) { 275 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); 276 Writer.AddTemplateArgument(T->getArgumentPack(), Record); 277 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK; 278} 279 280void 281ASTTypeWriter::VisitTemplateSpecializationType( 282 const TemplateSpecializationType *T) { 283 Record.push_back(T->isDependentType()); 284 Writer.AddTemplateName(T->getTemplateName(), Record); 285 Record.push_back(T->getNumArgs()); 286 for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end(); 287 ArgI != ArgE; ++ArgI) 288 Writer.AddTemplateArgument(*ArgI, Record); 289 Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() : 290 T->isCanonicalUnqualified() ? QualType() 291 : T->getCanonicalTypeInternal(), 292 Record); 293 Code = TYPE_TEMPLATE_SPECIALIZATION; 294} 295 296void 297ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { 298 VisitArrayType(T); 299 Writer.AddStmt(T->getSizeExpr()); 300 Writer.AddSourceRange(T->getBracketsRange(), Record); 301 Code = TYPE_DEPENDENT_SIZED_ARRAY; 302} 303 304void 305ASTTypeWriter::VisitDependentSizedExtVectorType( 306 const DependentSizedExtVectorType *T) { 307 // FIXME: Serialize this type (C++ only) 308 llvm_unreachable("Cannot serialize dependent sized extended vector types"); 309} 310 311void 312ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { 313 Record.push_back(T->getDepth()); 314 Record.push_back(T->getIndex()); 315 Record.push_back(T->isParameterPack()); 316 Writer.AddDeclRef(T->getDecl(), Record); 317 Code = TYPE_TEMPLATE_TYPE_PARM; 318} 319 320void 321ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { 322 Record.push_back(T->getKeyword()); 323 Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 324 Writer.AddIdentifierRef(T->getIdentifier(), Record); 325 Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() 326 : T->getCanonicalTypeInternal(), 327 Record); 328 Code = TYPE_DEPENDENT_NAME; 329} 330 331void 332ASTTypeWriter::VisitDependentTemplateSpecializationType( 333 const DependentTemplateSpecializationType *T) { 334 Record.push_back(T->getKeyword()); 335 Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 336 Writer.AddIdentifierRef(T->getIdentifier(), Record); 337 Record.push_back(T->getNumArgs()); 338 for (DependentTemplateSpecializationType::iterator 339 I = T->begin(), E = T->end(); I != E; ++I) 340 Writer.AddTemplateArgument(*I, Record); 341 Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; 342} 343 344void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { 345 Writer.AddTypeRef(T->getPattern(), Record); 346 if (llvm::Optional<unsigned> NumExpansions = T->getNumExpansions()) 347 Record.push_back(*NumExpansions + 1); 348 else 349 Record.push_back(0); 350 Code = TYPE_PACK_EXPANSION; 351} 352 353void ASTTypeWriter::VisitParenType(const ParenType *T) { 354 Writer.AddTypeRef(T->getInnerType(), Record); 355 Code = TYPE_PAREN; 356} 357 358void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { 359 Record.push_back(T->getKeyword()); 360 Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 361 Writer.AddTypeRef(T->getNamedType(), Record); 362 Code = TYPE_ELABORATED; 363} 364 365void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { 366 Writer.AddDeclRef(T->getDecl(), Record); 367 Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); 368 Code = TYPE_INJECTED_CLASS_NAME; 369} 370 371void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 372 Writer.AddDeclRef(T->getDecl(), Record); 373 Code = TYPE_OBJC_INTERFACE; 374} 375 376void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { 377 Writer.AddTypeRef(T->getBaseType(), Record); 378 Record.push_back(T->getNumProtocols()); 379 for (ObjCObjectType::qual_iterator I = T->qual_begin(), 380 E = T->qual_end(); I != E; ++I) 381 Writer.AddDeclRef(*I, Record); 382 Code = TYPE_OBJC_OBJECT; 383} 384 385void 386ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 387 Writer.AddTypeRef(T->getPointeeType(), Record); 388 Code = TYPE_OBJC_OBJECT_POINTER; 389} 390 391void 392ASTTypeWriter::VisitAtomicType(const AtomicType *T) { 393 Writer.AddTypeRef(T->getValueType(), Record); 394 Code = TYPE_ATOMIC; 395} 396 397namespace { 398 399class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> { 400 ASTWriter &Writer; 401 ASTWriter::RecordDataImpl &Record; 402 403public: 404 TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) 405 : Writer(Writer), Record(Record) { } 406 407#define ABSTRACT_TYPELOC(CLASS, PARENT) 408#define TYPELOC(CLASS, PARENT) \ 409 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 410#include "clang/AST/TypeLocNodes.def" 411 412 void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); 413 void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); 414}; 415 416} 417 418void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 419 // nothing to do 420} 421void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 422 Writer.AddSourceLocation(TL.getBuiltinLoc(), Record); 423 if (TL.needsExtraLocalData()) { 424 Record.push_back(TL.getWrittenTypeSpec()); 425 Record.push_back(TL.getWrittenSignSpec()); 426 Record.push_back(TL.getWrittenWidthSpec()); 427 Record.push_back(TL.hasModeAttr()); 428 } 429} 430void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { 431 Writer.AddSourceLocation(TL.getNameLoc(), Record); 432} 433void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { 434 Writer.AddSourceLocation(TL.getStarLoc(), Record); 435} 436void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 437 Writer.AddSourceLocation(TL.getCaretLoc(), Record); 438} 439void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 440 Writer.AddSourceLocation(TL.getAmpLoc(), Record); 441} 442void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 443 Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record); 444} 445void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 446 Writer.AddSourceLocation(TL.getStarLoc(), Record); 447 Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record); 448} 449void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { 450 Writer.AddSourceLocation(TL.getLBracketLoc(), Record); 451 Writer.AddSourceLocation(TL.getRBracketLoc(), Record); 452 Record.push_back(TL.getSizeExpr() ? 1 : 0); 453 if (TL.getSizeExpr()) 454 Writer.AddStmt(TL.getSizeExpr()); 455} 456void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 457 VisitArrayTypeLoc(TL); 458} 459void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 460 VisitArrayTypeLoc(TL); 461} 462void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 463 VisitArrayTypeLoc(TL); 464} 465void TypeLocWriter::VisitDependentSizedArrayTypeLoc( 466 DependentSizedArrayTypeLoc TL) { 467 VisitArrayTypeLoc(TL); 468} 469void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( 470 DependentSizedExtVectorTypeLoc TL) { 471 Writer.AddSourceLocation(TL.getNameLoc(), Record); 472} 473void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { 474 Writer.AddSourceLocation(TL.getNameLoc(), Record); 475} 476void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 477 Writer.AddSourceLocation(TL.getNameLoc(), Record); 478} 479void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 480 Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record); 481 Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record); 482 Record.push_back(TL.getTrailingReturn()); 483 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 484 Writer.AddDeclRef(TL.getArg(i), Record); 485} 486void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 487 VisitFunctionTypeLoc(TL); 488} 489void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 490 VisitFunctionTypeLoc(TL); 491} 492void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 493 Writer.AddSourceLocation(TL.getNameLoc(), Record); 494} 495void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 496 Writer.AddSourceLocation(TL.getNameLoc(), Record); 497} 498void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 499 Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 500 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 501 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 502} 503void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 504 Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 505 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 506 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 507 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); 508} 509void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 510 Writer.AddSourceLocation(TL.getNameLoc(), Record); 511} 512void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 513 Writer.AddSourceLocation(TL.getKWLoc(), Record); 514 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 515 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 516 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); 517} 518void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { 519 Writer.AddSourceLocation(TL.getNameLoc(), Record); 520} 521void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { 522 Writer.AddSourceLocation(TL.getNameLoc(), Record); 523} 524void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { 525 Writer.AddSourceLocation(TL.getNameLoc(), Record); 526} 527void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 528 Writer.AddSourceLocation(TL.getAttrNameLoc(), Record); 529 if (TL.hasAttrOperand()) { 530 SourceRange range = TL.getAttrOperandParensRange(); 531 Writer.AddSourceLocation(range.getBegin(), Record); 532 Writer.AddSourceLocation(range.getEnd(), Record); 533 } 534 if (TL.hasAttrExprOperand()) { 535 Expr *operand = TL.getAttrExprOperand(); 536 Record.push_back(operand ? 1 : 0); 537 if (operand) Writer.AddStmt(operand); 538 } else if (TL.hasAttrEnumOperand()) { 539 Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record); 540 } 541} 542void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 543 Writer.AddSourceLocation(TL.getNameLoc(), Record); 544} 545void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( 546 SubstTemplateTypeParmTypeLoc TL) { 547 Writer.AddSourceLocation(TL.getNameLoc(), Record); 548} 549void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( 550 SubstTemplateTypeParmPackTypeLoc TL) { 551 Writer.AddSourceLocation(TL.getNameLoc(), Record); 552} 553void TypeLocWriter::VisitTemplateSpecializationTypeLoc( 554 TemplateSpecializationTypeLoc TL) { 555 Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); 556 Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 557 Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 558 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 559 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), 560 TL.getArgLoc(i).getLocInfo(), Record); 561} 562void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { 563 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 564 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 565} 566void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 567 Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 568 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 569} 570void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 571 Writer.AddSourceLocation(TL.getNameLoc(), Record); 572} 573void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 574 Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 575 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 576 Writer.AddSourceLocation(TL.getNameLoc(), Record); 577} 578void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( 579 DependentTemplateSpecializationTypeLoc TL) { 580 Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 581 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 582 Writer.AddSourceLocation(TL.getNameLoc(), Record); 583 Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 584 Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 585 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 586 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), 587 TL.getArgLoc(I).getLocInfo(), Record); 588} 589void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 590 Writer.AddSourceLocation(TL.getEllipsisLoc(), Record); 591} 592void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 593 Writer.AddSourceLocation(TL.getNameLoc(), Record); 594} 595void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 596 Record.push_back(TL.hasBaseTypeAsWritten()); 597 Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 598 Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 599 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 600 Writer.AddSourceLocation(TL.getProtocolLoc(i), Record); 601} 602void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 603 Writer.AddSourceLocation(TL.getStarLoc(), Record); 604} 605void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 606 Writer.AddSourceLocation(TL.getKWLoc(), Record); 607 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 608 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 609} 610 611//===----------------------------------------------------------------------===// 612// ASTWriter Implementation 613//===----------------------------------------------------------------------===// 614 615static void EmitBlockID(unsigned ID, const char *Name, 616 llvm::BitstreamWriter &Stream, 617 ASTWriter::RecordDataImpl &Record) { 618 Record.clear(); 619 Record.push_back(ID); 620 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); 621 622 // Emit the block name if present. 623 if (Name == 0 || Name[0] == 0) return; 624 Record.clear(); 625 while (*Name) 626 Record.push_back(*Name++); 627 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); 628} 629 630static void EmitRecordID(unsigned ID, const char *Name, 631 llvm::BitstreamWriter &Stream, 632 ASTWriter::RecordDataImpl &Record) { 633 Record.clear(); 634 Record.push_back(ID); 635 while (*Name) 636 Record.push_back(*Name++); 637 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); 638} 639 640static void AddStmtsExprs(llvm::BitstreamWriter &Stream, 641 ASTWriter::RecordDataImpl &Record) { 642#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 643 RECORD(STMT_STOP); 644 RECORD(STMT_NULL_PTR); 645 RECORD(STMT_NULL); 646 RECORD(STMT_COMPOUND); 647 RECORD(STMT_CASE); 648 RECORD(STMT_DEFAULT); 649 RECORD(STMT_LABEL); 650 RECORD(STMT_IF); 651 RECORD(STMT_SWITCH); 652 RECORD(STMT_WHILE); 653 RECORD(STMT_DO); 654 RECORD(STMT_FOR); 655 RECORD(STMT_GOTO); 656 RECORD(STMT_INDIRECT_GOTO); 657 RECORD(STMT_CONTINUE); 658 RECORD(STMT_BREAK); 659 RECORD(STMT_RETURN); 660 RECORD(STMT_DECL); 661 RECORD(STMT_ASM); 662 RECORD(EXPR_PREDEFINED); 663 RECORD(EXPR_DECL_REF); 664 RECORD(EXPR_INTEGER_LITERAL); 665 RECORD(EXPR_FLOATING_LITERAL); 666 RECORD(EXPR_IMAGINARY_LITERAL); 667 RECORD(EXPR_STRING_LITERAL); 668 RECORD(EXPR_CHARACTER_LITERAL); 669 RECORD(EXPR_PAREN); 670 RECORD(EXPR_UNARY_OPERATOR); 671 RECORD(EXPR_SIZEOF_ALIGN_OF); 672 RECORD(EXPR_ARRAY_SUBSCRIPT); 673 RECORD(EXPR_CALL); 674 RECORD(EXPR_MEMBER); 675 RECORD(EXPR_BINARY_OPERATOR); 676 RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); 677 RECORD(EXPR_CONDITIONAL_OPERATOR); 678 RECORD(EXPR_IMPLICIT_CAST); 679 RECORD(EXPR_CSTYLE_CAST); 680 RECORD(EXPR_COMPOUND_LITERAL); 681 RECORD(EXPR_EXT_VECTOR_ELEMENT); 682 RECORD(EXPR_INIT_LIST); 683 RECORD(EXPR_DESIGNATED_INIT); 684 RECORD(EXPR_IMPLICIT_VALUE_INIT); 685 RECORD(EXPR_VA_ARG); 686 RECORD(EXPR_ADDR_LABEL); 687 RECORD(EXPR_STMT); 688 RECORD(EXPR_CHOOSE); 689 RECORD(EXPR_GNU_NULL); 690 RECORD(EXPR_SHUFFLE_VECTOR); 691 RECORD(EXPR_BLOCK); 692 RECORD(EXPR_BLOCK_DECL_REF); 693 RECORD(EXPR_GENERIC_SELECTION); 694 RECORD(EXPR_OBJC_STRING_LITERAL); 695 RECORD(EXPR_OBJC_ENCODE); 696 RECORD(EXPR_OBJC_SELECTOR_EXPR); 697 RECORD(EXPR_OBJC_PROTOCOL_EXPR); 698 RECORD(EXPR_OBJC_IVAR_REF_EXPR); 699 RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); 700 RECORD(EXPR_OBJC_KVC_REF_EXPR); 701 RECORD(EXPR_OBJC_MESSAGE_EXPR); 702 RECORD(STMT_OBJC_FOR_COLLECTION); 703 RECORD(STMT_OBJC_CATCH); 704 RECORD(STMT_OBJC_FINALLY); 705 RECORD(STMT_OBJC_AT_TRY); 706 RECORD(STMT_OBJC_AT_SYNCHRONIZED); 707 RECORD(STMT_OBJC_AT_THROW); 708 RECORD(EXPR_CXX_OPERATOR_CALL); 709 RECORD(EXPR_CXX_CONSTRUCT); 710 RECORD(EXPR_CXX_STATIC_CAST); 711 RECORD(EXPR_CXX_DYNAMIC_CAST); 712 RECORD(EXPR_CXX_REINTERPRET_CAST); 713 RECORD(EXPR_CXX_CONST_CAST); 714 RECORD(EXPR_CXX_FUNCTIONAL_CAST); 715 RECORD(EXPR_CXX_BOOL_LITERAL); 716 RECORD(EXPR_CXX_NULL_PTR_LITERAL); 717 RECORD(EXPR_CXX_TYPEID_EXPR); 718 RECORD(EXPR_CXX_TYPEID_TYPE); 719 RECORD(EXPR_CXX_UUIDOF_EXPR); 720 RECORD(EXPR_CXX_UUIDOF_TYPE); 721 RECORD(EXPR_CXX_THIS); 722 RECORD(EXPR_CXX_THROW); 723 RECORD(EXPR_CXX_DEFAULT_ARG); 724 RECORD(EXPR_CXX_BIND_TEMPORARY); 725 RECORD(EXPR_CXX_SCALAR_VALUE_INIT); 726 RECORD(EXPR_CXX_NEW); 727 RECORD(EXPR_CXX_DELETE); 728 RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR); 729 RECORD(EXPR_EXPR_WITH_CLEANUPS); 730 RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER); 731 RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF); 732 RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT); 733 RECORD(EXPR_CXX_UNRESOLVED_MEMBER); 734 RECORD(EXPR_CXX_UNRESOLVED_LOOKUP); 735 RECORD(EXPR_CXX_UNARY_TYPE_TRAIT); 736 RECORD(EXPR_CXX_NOEXCEPT); 737 RECORD(EXPR_OPAQUE_VALUE); 738 RECORD(EXPR_BINARY_TYPE_TRAIT); 739 RECORD(EXPR_PACK_EXPANSION); 740 RECORD(EXPR_SIZEOF_PACK); 741 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK); 742 RECORD(EXPR_CUDA_KERNEL_CALL); 743#undef RECORD 744} 745 746void ASTWriter::WriteBlockInfoBlock() { 747 RecordData Record; 748 Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); 749 750#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) 751#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 752 753 // AST Top-Level Block. 754 BLOCK(AST_BLOCK); 755 RECORD(ORIGINAL_FILE_NAME); 756 RECORD(ORIGINAL_FILE_ID); 757 RECORD(TYPE_OFFSET); 758 RECORD(DECL_OFFSET); 759 RECORD(LANGUAGE_OPTIONS); 760 RECORD(METADATA); 761 RECORD(IDENTIFIER_OFFSET); 762 RECORD(IDENTIFIER_TABLE); 763 RECORD(EXTERNAL_DEFINITIONS); 764 RECORD(SPECIAL_TYPES); 765 RECORD(STATISTICS); 766 RECORD(TENTATIVE_DEFINITIONS); 767 RECORD(UNUSED_FILESCOPED_DECLS); 768 RECORD(LOCALLY_SCOPED_EXTERNAL_DECLS); 769 RECORD(SELECTOR_OFFSETS); 770 RECORD(METHOD_POOL); 771 RECORD(PP_COUNTER_VALUE); 772 RECORD(SOURCE_LOCATION_OFFSETS); 773 RECORD(SOURCE_LOCATION_PRELOADS); 774 RECORD(STAT_CACHE); 775 RECORD(EXT_VECTOR_DECLS); 776 RECORD(VERSION_CONTROL_BRANCH_REVISION); 777 RECORD(PPD_ENTITIES_OFFSETS); 778 RECORD(IMPORTS); 779 RECORD(REFERENCED_SELECTOR_POOL); 780 RECORD(TU_UPDATE_LEXICAL); 781 RECORD(REDECLS_UPDATE_LATEST); 782 RECORD(SEMA_DECL_REFS); 783 RECORD(WEAK_UNDECLARED_IDENTIFIERS); 784 RECORD(PENDING_IMPLICIT_INSTANTIATIONS); 785 RECORD(DECL_REPLACEMENTS); 786 RECORD(UPDATE_VISIBLE); 787 RECORD(DECL_UPDATE_OFFSETS); 788 RECORD(DECL_UPDATES); 789 RECORD(CXX_BASE_SPECIFIER_OFFSETS); 790 RECORD(DIAG_PRAGMA_MAPPINGS); 791 RECORD(CUDA_SPECIAL_DECL_REFS); 792 RECORD(HEADER_SEARCH_TABLE); 793 RECORD(ORIGINAL_PCH_DIR); 794 RECORD(FP_PRAGMA_OPTIONS); 795 RECORD(OPENCL_EXTENSIONS); 796 RECORD(DELEGATING_CTORS); 797 RECORD(FILE_SOURCE_LOCATION_OFFSETS); 798 RECORD(KNOWN_NAMESPACES); 799 RECORD(MODULE_OFFSET_MAP); 800 RECORD(SOURCE_MANAGER_LINE_TABLE); 801 802 // SourceManager Block. 803 BLOCK(SOURCE_MANAGER_BLOCK); 804 RECORD(SM_SLOC_FILE_ENTRY); 805 RECORD(SM_SLOC_BUFFER_ENTRY); 806 RECORD(SM_SLOC_BUFFER_BLOB); 807 RECORD(SM_SLOC_EXPANSION_ENTRY); 808 809 // Preprocessor Block. 810 BLOCK(PREPROCESSOR_BLOCK); 811 RECORD(PP_MACRO_OBJECT_LIKE); 812 RECORD(PP_MACRO_FUNCTION_LIKE); 813 RECORD(PP_TOKEN); 814 815 // Decls and Types block. 816 BLOCK(DECLTYPES_BLOCK); 817 RECORD(TYPE_EXT_QUAL); 818 RECORD(TYPE_COMPLEX); 819 RECORD(TYPE_POINTER); 820 RECORD(TYPE_BLOCK_POINTER); 821 RECORD(TYPE_LVALUE_REFERENCE); 822 RECORD(TYPE_RVALUE_REFERENCE); 823 RECORD(TYPE_MEMBER_POINTER); 824 RECORD(TYPE_CONSTANT_ARRAY); 825 RECORD(TYPE_INCOMPLETE_ARRAY); 826 RECORD(TYPE_VARIABLE_ARRAY); 827 RECORD(TYPE_VECTOR); 828 RECORD(TYPE_EXT_VECTOR); 829 RECORD(TYPE_FUNCTION_PROTO); 830 RECORD(TYPE_FUNCTION_NO_PROTO); 831 RECORD(TYPE_TYPEDEF); 832 RECORD(TYPE_TYPEOF_EXPR); 833 RECORD(TYPE_TYPEOF); 834 RECORD(TYPE_RECORD); 835 RECORD(TYPE_ENUM); 836 RECORD(TYPE_OBJC_INTERFACE); 837 RECORD(TYPE_OBJC_OBJECT); 838 RECORD(TYPE_OBJC_OBJECT_POINTER); 839 RECORD(TYPE_DECLTYPE); 840 RECORD(TYPE_ELABORATED); 841 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM); 842 RECORD(TYPE_UNRESOLVED_USING); 843 RECORD(TYPE_INJECTED_CLASS_NAME); 844 RECORD(TYPE_OBJC_OBJECT); 845 RECORD(TYPE_TEMPLATE_TYPE_PARM); 846 RECORD(TYPE_TEMPLATE_SPECIALIZATION); 847 RECORD(TYPE_DEPENDENT_NAME); 848 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION); 849 RECORD(TYPE_DEPENDENT_SIZED_ARRAY); 850 RECORD(TYPE_PAREN); 851 RECORD(TYPE_PACK_EXPANSION); 852 RECORD(TYPE_ATTRIBUTED); 853 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK); 854 RECORD(TYPE_ATOMIC); 855 RECORD(DECL_TYPEDEF); 856 RECORD(DECL_ENUM); 857 RECORD(DECL_RECORD); 858 RECORD(DECL_ENUM_CONSTANT); 859 RECORD(DECL_FUNCTION); 860 RECORD(DECL_OBJC_METHOD); 861 RECORD(DECL_OBJC_INTERFACE); 862 RECORD(DECL_OBJC_PROTOCOL); 863 RECORD(DECL_OBJC_IVAR); 864 RECORD(DECL_OBJC_AT_DEFS_FIELD); 865 RECORD(DECL_OBJC_CLASS); 866 RECORD(DECL_OBJC_FORWARD_PROTOCOL); 867 RECORD(DECL_OBJC_CATEGORY); 868 RECORD(DECL_OBJC_CATEGORY_IMPL); 869 RECORD(DECL_OBJC_IMPLEMENTATION); 870 RECORD(DECL_OBJC_COMPATIBLE_ALIAS); 871 RECORD(DECL_OBJC_PROPERTY); 872 RECORD(DECL_OBJC_PROPERTY_IMPL); 873 RECORD(DECL_FIELD); 874 RECORD(DECL_VAR); 875 RECORD(DECL_IMPLICIT_PARAM); 876 RECORD(DECL_PARM_VAR); 877 RECORD(DECL_FILE_SCOPE_ASM); 878 RECORD(DECL_BLOCK); 879 RECORD(DECL_CONTEXT_LEXICAL); 880 RECORD(DECL_CONTEXT_VISIBLE); 881 RECORD(DECL_NAMESPACE); 882 RECORD(DECL_NAMESPACE_ALIAS); 883 RECORD(DECL_USING); 884 RECORD(DECL_USING_SHADOW); 885 RECORD(DECL_USING_DIRECTIVE); 886 RECORD(DECL_UNRESOLVED_USING_VALUE); 887 RECORD(DECL_UNRESOLVED_USING_TYPENAME); 888 RECORD(DECL_LINKAGE_SPEC); 889 RECORD(DECL_CXX_RECORD); 890 RECORD(DECL_CXX_METHOD); 891 RECORD(DECL_CXX_CONSTRUCTOR); 892 RECORD(DECL_CXX_DESTRUCTOR); 893 RECORD(DECL_CXX_CONVERSION); 894 RECORD(DECL_ACCESS_SPEC); 895 RECORD(DECL_FRIEND); 896 RECORD(DECL_FRIEND_TEMPLATE); 897 RECORD(DECL_CLASS_TEMPLATE); 898 RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION); 899 RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION); 900 RECORD(DECL_FUNCTION_TEMPLATE); 901 RECORD(DECL_TEMPLATE_TYPE_PARM); 902 RECORD(DECL_NON_TYPE_TEMPLATE_PARM); 903 RECORD(DECL_TEMPLATE_TEMPLATE_PARM); 904 RECORD(DECL_STATIC_ASSERT); 905 RECORD(DECL_CXX_BASE_SPECIFIERS); 906 RECORD(DECL_INDIRECTFIELD); 907 RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK); 908 909 // Statements and Exprs can occur in the Decls and Types block. 910 AddStmtsExprs(Stream, Record); 911 912 BLOCK(PREPROCESSOR_DETAIL_BLOCK); 913 RECORD(PPD_MACRO_EXPANSION); 914 RECORD(PPD_MACRO_DEFINITION); 915 RECORD(PPD_INCLUSION_DIRECTIVE); 916 917#undef RECORD 918#undef BLOCK 919 Stream.ExitBlock(); 920} 921 922/// \brief Adjusts the given filename to only write out the portion of the 923/// filename that is not part of the system root directory. 924/// 925/// \param Filename the file name to adjust. 926/// 927/// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and 928/// the returned filename will be adjusted by this system root. 929/// 930/// \returns either the original filename (if it needs no adjustment) or the 931/// adjusted filename (which points into the @p Filename parameter). 932static const char * 933adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) { 934 assert(Filename && "No file name to adjust?"); 935 936 if (isysroot.empty()) 937 return Filename; 938 939 // Verify that the filename and the system root have the same prefix. 940 unsigned Pos = 0; 941 for (; Filename[Pos] && Pos < isysroot.size(); ++Pos) 942 if (Filename[Pos] != isysroot[Pos]) 943 return Filename; // Prefixes don't match. 944 945 // We hit the end of the filename before we hit the end of the system root. 946 if (!Filename[Pos]) 947 return Filename; 948 949 // If the file name has a '/' at the current position, skip over the '/'. 950 // We distinguish sysroot-based includes from absolute includes by the 951 // absence of '/' at the beginning of sysroot-based includes. 952 if (Filename[Pos] == '/') 953 ++Pos; 954 955 return Filename + Pos; 956} 957 958/// \brief Write the AST metadata (e.g., i686-apple-darwin9). 959void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot, 960 const std::string &OutputFile) { 961 using namespace llvm; 962 963 // Metadata 964 const TargetInfo &Target = Context.getTargetInfo(); 965 BitCodeAbbrev *MetaAbbrev = new BitCodeAbbrev(); 966 MetaAbbrev->Add(BitCodeAbbrevOp(METADATA)); 967 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST major 968 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST minor 969 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major 970 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor 971 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable 972 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Target triple 973 unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev); 974 975 RecordData Record; 976 Record.push_back(METADATA); 977 Record.push_back(VERSION_MAJOR); 978 Record.push_back(VERSION_MINOR); 979 Record.push_back(CLANG_VERSION_MAJOR); 980 Record.push_back(CLANG_VERSION_MINOR); 981 Record.push_back(!isysroot.empty()); 982 const std::string &Triple = Target.getTriple().getTriple(); 983 Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, Triple); 984 985 if (Chain) { 986 serialization::ModuleManager &Mgr = Chain->getModuleManager(); 987 llvm::SmallVector<char, 128> ModulePaths; 988 Record.clear(); 989 990 for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end(); 991 M != MEnd; ++M) { 992 // Skip modules that weren't directly imported. 993 if (!(*M)->isDirectlyImported()) 994 continue; 995 996 Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding 997 // FIXME: Write import location, once it matters. 998 // FIXME: This writes the absolute path for AST files we depend on. 999 const std::string &FileName = (*M)->FileName; 1000 Record.push_back(FileName.size()); 1001 Record.append(FileName.begin(), FileName.end()); 1002 } 1003 Stream.EmitRecord(IMPORTS, Record); 1004 } 1005 1006 // Original file name and file ID 1007 SourceManager &SM = Context.getSourceManager(); 1008 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 1009 BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev(); 1010 FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE_NAME)); 1011 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1012 unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); 1013 1014 llvm::SmallString<128> MainFilePath(MainFile->getName()); 1015 1016 llvm::sys::fs::make_absolute(MainFilePath); 1017 1018 const char *MainFileNameStr = MainFilePath.c_str(); 1019 MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, 1020 isysroot); 1021 RecordData Record; 1022 Record.push_back(ORIGINAL_FILE_NAME); 1023 Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr); 1024 1025 Record.clear(); 1026 Record.push_back(SM.getMainFileID().getOpaqueValue()); 1027 Stream.EmitRecord(ORIGINAL_FILE_ID, Record); 1028 } 1029 1030 // Original PCH directory 1031 if (!OutputFile.empty() && OutputFile != "-") { 1032 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1033 Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR)); 1034 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1035 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 1036 1037 llvm::SmallString<128> OutputPath(OutputFile); 1038 1039 llvm::sys::fs::make_absolute(OutputPath); 1040 StringRef origDir = llvm::sys::path::parent_path(OutputPath); 1041 1042 RecordData Record; 1043 Record.push_back(ORIGINAL_PCH_DIR); 1044 Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); 1045 } 1046 1047 // Repository branch/version information. 1048 BitCodeAbbrev *RepoAbbrev = new BitCodeAbbrev(); 1049 RepoAbbrev->Add(BitCodeAbbrevOp(VERSION_CONTROL_BRANCH_REVISION)); 1050 RepoAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag 1051 unsigned RepoAbbrevCode = Stream.EmitAbbrev(RepoAbbrev); 1052 Record.clear(); 1053 Record.push_back(VERSION_CONTROL_BRANCH_REVISION); 1054 Stream.EmitRecordWithBlob(RepoAbbrevCode, Record, 1055 getClangFullRepositoryVersion()); 1056} 1057 1058/// \brief Write the LangOptions structure. 1059void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) { 1060 RecordData Record; 1061#define LANGOPT(Name, Bits, Default, Description) \ 1062 Record.push_back(LangOpts.Name); 1063#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 1064 Record.push_back(static_cast<unsigned>(LangOpts.get##Name())); 1065#include "clang/Basic/LangOptions.def" 1066 1067 Record.push_back(LangOpts.CurrentModule.size()); 1068 Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end()); 1069 Stream.EmitRecord(LANGUAGE_OPTIONS, Record); 1070} 1071 1072//===----------------------------------------------------------------------===// 1073// stat cache Serialization 1074//===----------------------------------------------------------------------===// 1075 1076namespace { 1077// Trait used for the on-disk hash table of stat cache results. 1078class ASTStatCacheTrait { 1079public: 1080 typedef const char * key_type; 1081 typedef key_type key_type_ref; 1082 1083 typedef struct stat data_type; 1084 typedef const data_type &data_type_ref; 1085 1086 static unsigned ComputeHash(const char *path) { 1087 return llvm::HashString(path); 1088 } 1089 1090 std::pair<unsigned,unsigned> 1091 EmitKeyDataLength(raw_ostream& Out, const char *path, 1092 data_type_ref Data) { 1093 unsigned StrLen = strlen(path); 1094 clang::io::Emit16(Out, StrLen); 1095 unsigned DataLen = 4 + 4 + 2 + 8 + 8; 1096 clang::io::Emit8(Out, DataLen); 1097 return std::make_pair(StrLen + 1, DataLen); 1098 } 1099 1100 void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) { 1101 Out.write(path, KeyLen); 1102 } 1103 1104 void EmitData(raw_ostream &Out, key_type_ref, 1105 data_type_ref Data, unsigned DataLen) { 1106 using namespace clang::io; 1107 uint64_t Start = Out.tell(); (void)Start; 1108 1109 Emit32(Out, (uint32_t) Data.st_ino); 1110 Emit32(Out, (uint32_t) Data.st_dev); 1111 Emit16(Out, (uint16_t) Data.st_mode); 1112 Emit64(Out, (uint64_t) Data.st_mtime); 1113 Emit64(Out, (uint64_t) Data.st_size); 1114 1115 assert(Out.tell() - Start == DataLen && "Wrong data length"); 1116 } 1117}; 1118} // end anonymous namespace 1119 1120/// \brief Write the stat() system call cache to the AST file. 1121void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) { 1122 // Build the on-disk hash table containing information about every 1123 // stat() call. 1124 OnDiskChainedHashTableGenerator<ASTStatCacheTrait> Generator; 1125 unsigned NumStatEntries = 0; 1126 for (MemorizeStatCalls::iterator Stat = StatCalls.begin(), 1127 StatEnd = StatCalls.end(); 1128 Stat != StatEnd; ++Stat, ++NumStatEntries) { 1129 StringRef Filename = Stat->first(); 1130 Generator.insert(Filename.data(), Stat->second); 1131 } 1132 1133 // Create the on-disk hash table in a buffer. 1134 llvm::SmallString<4096> StatCacheData; 1135 uint32_t BucketOffset; 1136 { 1137 llvm::raw_svector_ostream Out(StatCacheData); 1138 // Make sure that no bucket is at offset 0 1139 clang::io::Emit32(Out, 0); 1140 BucketOffset = Generator.Emit(Out); 1141 } 1142 1143 // Create a blob abbreviation 1144 using namespace llvm; 1145 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1146 Abbrev->Add(BitCodeAbbrevOp(STAT_CACHE)); 1147 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1148 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1149 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1150 unsigned StatCacheAbbrev = Stream.EmitAbbrev(Abbrev); 1151 1152 // Write the stat cache 1153 RecordData Record; 1154 Record.push_back(STAT_CACHE); 1155 Record.push_back(BucketOffset); 1156 Record.push_back(NumStatEntries); 1157 Stream.EmitRecordWithBlob(StatCacheAbbrev, Record, StatCacheData.str()); 1158} 1159 1160//===----------------------------------------------------------------------===// 1161// Source Manager Serialization 1162//===----------------------------------------------------------------------===// 1163 1164/// \brief Create an abbreviation for the SLocEntry that refers to a 1165/// file. 1166static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { 1167 using namespace llvm; 1168 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1169 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); 1170 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1171 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1172 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1173 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1174 // FileEntry fields. 1175 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size 1176 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time 1177 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // BufferOverridden 1178 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs 1179 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex 1180 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls 1181 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1182 return Stream.EmitAbbrev(Abbrev); 1183} 1184 1185/// \brief Create an abbreviation for the SLocEntry that refers to a 1186/// buffer. 1187static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { 1188 using namespace llvm; 1189 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1190 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); 1191 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1192 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1193 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1194 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1195 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob 1196 return Stream.EmitAbbrev(Abbrev); 1197} 1198 1199/// \brief Create an abbreviation for the SLocEntry that refers to a 1200/// buffer's blob. 1201static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { 1202 using namespace llvm; 1203 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1204 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB)); 1205 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob 1206 return Stream.EmitAbbrev(Abbrev); 1207} 1208 1209/// \brief Create an abbreviation for the SLocEntry that refers to a macro 1210/// expansion. 1211static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) { 1212 using namespace llvm; 1213 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1214 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY)); 1215 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1216 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location 1217 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location 1218 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location 1219 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length 1220 return Stream.EmitAbbrev(Abbrev); 1221} 1222 1223namespace { 1224 // Trait used for the on-disk hash table of header search information. 1225 class HeaderFileInfoTrait { 1226 ASTWriter &Writer; 1227 const HeaderSearch &HS; 1228 1229 // Keep track of the framework names we've used during serialization. 1230 SmallVector<char, 128> FrameworkStringData; 1231 llvm::StringMap<unsigned> FrameworkNameOffset; 1232 1233 public: 1234 HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS) 1235 : Writer(Writer), HS(HS) { } 1236 1237 typedef const char *key_type; 1238 typedef key_type key_type_ref; 1239 1240 typedef HeaderFileInfo data_type; 1241 typedef const data_type &data_type_ref; 1242 1243 static unsigned ComputeHash(const char *path) { 1244 // The hash is based only on the filename portion of the key, so that the 1245 // reader can match based on filenames when symlinking or excess path 1246 // elements ("foo/../", "../") change the form of the name. However, 1247 // complete path is still the key. 1248 return llvm::HashString(llvm::sys::path::filename(path)); 1249 } 1250 1251 std::pair<unsigned,unsigned> 1252 EmitKeyDataLength(raw_ostream& Out, const char *path, 1253 data_type_ref Data) { 1254 unsigned StrLen = strlen(path); 1255 clang::io::Emit16(Out, StrLen); 1256 unsigned DataLen = 1 + 2 + 4 + 4; 1257 clang::io::Emit8(Out, DataLen); 1258 return std::make_pair(StrLen + 1, DataLen); 1259 } 1260 1261 void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) { 1262 Out.write(path, KeyLen); 1263 } 1264 1265 void EmitData(raw_ostream &Out, key_type_ref, 1266 data_type_ref Data, unsigned DataLen) { 1267 using namespace clang::io; 1268 uint64_t Start = Out.tell(); (void)Start; 1269 1270 unsigned char Flags = (Data.isImport << 5) 1271 | (Data.isPragmaOnce << 4) 1272 | (Data.DirInfo << 2) 1273 | (Data.Resolved << 1) 1274 | Data.IndexHeaderMapHeader; 1275 Emit8(Out, (uint8_t)Flags); 1276 Emit16(Out, (uint16_t) Data.NumIncludes); 1277 1278 if (!Data.ControllingMacro) 1279 Emit32(Out, (uint32_t)Data.ControllingMacroID); 1280 else 1281 Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro)); 1282 1283 unsigned Offset = 0; 1284 if (!Data.Framework.empty()) { 1285 // If this header refers into a framework, save the framework name. 1286 llvm::StringMap<unsigned>::iterator Pos 1287 = FrameworkNameOffset.find(Data.Framework); 1288 if (Pos == FrameworkNameOffset.end()) { 1289 Offset = FrameworkStringData.size() + 1; 1290 FrameworkStringData.append(Data.Framework.begin(), 1291 Data.Framework.end()); 1292 FrameworkStringData.push_back(0); 1293 1294 FrameworkNameOffset[Data.Framework] = Offset; 1295 } else 1296 Offset = Pos->second; 1297 } 1298 Emit32(Out, Offset); 1299 1300 assert(Out.tell() - Start == DataLen && "Wrong data length"); 1301 } 1302 1303 const char *strings_begin() const { return FrameworkStringData.begin(); } 1304 const char *strings_end() const { return FrameworkStringData.end(); } 1305 }; 1306} // end anonymous namespace 1307 1308/// \brief Write the header search block for the list of files that 1309/// 1310/// \param HS The header search structure to save. 1311/// 1312/// \param Chain Whether we're creating a chained AST file. 1313void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) { 1314 SmallVector<const FileEntry *, 16> FilesByUID; 1315 HS.getFileMgr().GetUniqueIDMapping(FilesByUID); 1316 1317 if (FilesByUID.size() > HS.header_file_size()) 1318 FilesByUID.resize(HS.header_file_size()); 1319 1320 HeaderFileInfoTrait GeneratorTrait(*this, HS); 1321 OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator; 1322 SmallVector<const char *, 4> SavedStrings; 1323 unsigned NumHeaderSearchEntries = 0; 1324 for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { 1325 const FileEntry *File = FilesByUID[UID]; 1326 if (!File) 1327 continue; 1328 1329 // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo 1330 // from the external source if it was not provided already. 1331 const HeaderFileInfo &HFI = HS.getFileInfo(File); 1332 if (HFI.External && Chain) 1333 continue; 1334 1335 // Turn the file name into an absolute path, if it isn't already. 1336 const char *Filename = File->getName(); 1337 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1338 1339 // If we performed any translation on the file name at all, we need to 1340 // save this string, since the generator will refer to it later. 1341 if (Filename != File->getName()) { 1342 Filename = strdup(Filename); 1343 SavedStrings.push_back(Filename); 1344 } 1345 1346 Generator.insert(Filename, HFI, GeneratorTrait); 1347 ++NumHeaderSearchEntries; 1348 } 1349 1350 // Create the on-disk hash table in a buffer. 1351 llvm::SmallString<4096> TableData; 1352 uint32_t BucketOffset; 1353 { 1354 llvm::raw_svector_ostream Out(TableData); 1355 // Make sure that no bucket is at offset 0 1356 clang::io::Emit32(Out, 0); 1357 BucketOffset = Generator.Emit(Out, GeneratorTrait); 1358 } 1359 1360 // Create a blob abbreviation 1361 using namespace llvm; 1362 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1363 Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); 1364 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1365 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1366 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1367 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1368 unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); 1369 1370 // Write the header search table 1371 RecordData Record; 1372 Record.push_back(HEADER_SEARCH_TABLE); 1373 Record.push_back(BucketOffset); 1374 Record.push_back(NumHeaderSearchEntries); 1375 Record.push_back(TableData.size()); 1376 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); 1377 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str()); 1378 1379 // Free all of the strings we had to duplicate. 1380 for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) 1381 free((void*)SavedStrings[I]); 1382} 1383 1384/// \brief Writes the block containing the serialized form of the 1385/// source manager. 1386/// 1387/// TODO: We should probably use an on-disk hash table (stored in a 1388/// blob), indexed based on the file name, so that we only create 1389/// entries for files that we actually need. In the common case (no 1390/// errors), we probably won't have to create file entries for any of 1391/// the files in the AST. 1392void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, 1393 const Preprocessor &PP, 1394 StringRef isysroot) { 1395 RecordData Record; 1396 1397 // Enter the source manager block. 1398 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3); 1399 1400 // Abbreviations for the various kinds of source-location entries. 1401 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); 1402 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); 1403 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); 1404 unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream); 1405 1406 // Write out the source location entry table. We skip the first 1407 // entry, which is always the same dummy entry. 1408 std::vector<uint32_t> SLocEntryOffsets; 1409 // Write out the offsets of only source location file entries. 1410 // We will go through them in ASTReader::validateFileEntries(). 1411 std::vector<uint32_t> SLocFileEntryOffsets; 1412 RecordData PreloadSLocs; 1413 SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1); 1414 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); 1415 I != N; ++I) { 1416 // Get this source location entry. 1417 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); 1418 1419 // Record the offset of this source-location entry. 1420 SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); 1421 1422 // Figure out which record code to use. 1423 unsigned Code; 1424 if (SLoc->isFile()) { 1425 const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); 1426 if (Cache->OrigEntry) { 1427 Code = SM_SLOC_FILE_ENTRY; 1428 SLocFileEntryOffsets.push_back(Stream.GetCurrentBitNo()); 1429 } else 1430 Code = SM_SLOC_BUFFER_ENTRY; 1431 } else 1432 Code = SM_SLOC_EXPANSION_ENTRY; 1433 Record.clear(); 1434 Record.push_back(Code); 1435 1436 // Starting offset of this entry within this module, so skip the dummy. 1437 Record.push_back(SLoc->getOffset() - 2); 1438 if (SLoc->isFile()) { 1439 const SrcMgr::FileInfo &File = SLoc->getFile(); 1440 Record.push_back(File.getIncludeLoc().getRawEncoding()); 1441 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding 1442 Record.push_back(File.hasLineDirectives()); 1443 1444 const SrcMgr::ContentCache *Content = File.getContentCache(); 1445 if (Content->OrigEntry) { 1446 assert(Content->OrigEntry == Content->ContentsEntry && 1447 "Writing to AST an overridden file is not supported"); 1448 1449 // The source location entry is a file. The blob associated 1450 // with this entry is the file name. 1451 1452 // Emit size/modification time for this file. 1453 Record.push_back(Content->OrigEntry->getSize()); 1454 Record.push_back(Content->OrigEntry->getModificationTime()); 1455 Record.push_back(Content->BufferOverridden); 1456 Record.push_back(File.NumCreatedFIDs); 1457 1458 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(SLoc); 1459 if (FDI != FileDeclIDs.end()) { 1460 Record.push_back(FDI->second->FirstDeclIndex); 1461 Record.push_back(FDI->second->DeclIDs.size()); 1462 } else { 1463 Record.push_back(0); 1464 Record.push_back(0); 1465 } 1466 1467 // Turn the file name into an absolute path, if it isn't already. 1468 const char *Filename = Content->OrigEntry->getName(); 1469 llvm::SmallString<128> FilePath(Filename); 1470 1471 // Ask the file manager to fixup the relative path for us. This will 1472 // honor the working directory. 1473 SourceMgr.getFileManager().FixupRelativePath(FilePath); 1474 1475 // FIXME: This call to make_absolute shouldn't be necessary, the 1476 // call to FixupRelativePath should always return an absolute path. 1477 llvm::sys::fs::make_absolute(FilePath); 1478 Filename = FilePath.c_str(); 1479 1480 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1481 Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename); 1482 1483 if (Content->BufferOverridden) { 1484 Record.clear(); 1485 Record.push_back(SM_SLOC_BUFFER_BLOB); 1486 const llvm::MemoryBuffer *Buffer 1487 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 1488 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, 1489 StringRef(Buffer->getBufferStart(), 1490 Buffer->getBufferSize() + 1)); 1491 } 1492 } else { 1493 // The source location entry is a buffer. The blob associated 1494 // with this entry contains the contents of the buffer. 1495 1496 // We add one to the size so that we capture the trailing NULL 1497 // that is required by llvm::MemoryBuffer::getMemBuffer (on 1498 // the reader side). 1499 const llvm::MemoryBuffer *Buffer 1500 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 1501 const char *Name = Buffer->getBufferIdentifier(); 1502 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, 1503 StringRef(Name, strlen(Name) + 1)); 1504 Record.clear(); 1505 Record.push_back(SM_SLOC_BUFFER_BLOB); 1506 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, 1507 StringRef(Buffer->getBufferStart(), 1508 Buffer->getBufferSize() + 1)); 1509 1510 if (strcmp(Name, "<built-in>") == 0) { 1511 PreloadSLocs.push_back(SLocEntryOffsets.size()); 1512 } 1513 } 1514 } else { 1515 // The source location entry is a macro expansion. 1516 const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); 1517 Record.push_back(Expansion.getSpellingLoc().getRawEncoding()); 1518 Record.push_back(Expansion.getExpansionLocStart().getRawEncoding()); 1519 Record.push_back(Expansion.isMacroArgExpansion() ? 0 1520 : Expansion.getExpansionLocEnd().getRawEncoding()); 1521 1522 // Compute the token length for this macro expansion. 1523 unsigned NextOffset = SourceMgr.getNextLocalOffset(); 1524 if (I + 1 != N) 1525 NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset(); 1526 Record.push_back(NextOffset - SLoc->getOffset() - 1); 1527 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record); 1528 } 1529 } 1530 1531 Stream.ExitBlock(); 1532 1533 if (SLocEntryOffsets.empty()) 1534 return; 1535 1536 // Write the source-location offsets table into the AST block. This 1537 // table is used for lazily loading source-location information. 1538 using namespace llvm; 1539 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1540 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); 1541 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs 1542 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size 1543 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets 1544 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); 1545 1546 Record.clear(); 1547 Record.push_back(SOURCE_LOCATION_OFFSETS); 1548 Record.push_back(SLocEntryOffsets.size()); 1549 Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy 1550 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets)); 1551 1552 Abbrev = new BitCodeAbbrev(); 1553 Abbrev->Add(BitCodeAbbrevOp(FILE_SOURCE_LOCATION_OFFSETS)); 1554 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs 1555 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets 1556 unsigned SLocFileOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); 1557 1558 Record.clear(); 1559 Record.push_back(FILE_SOURCE_LOCATION_OFFSETS); 1560 Record.push_back(SLocFileEntryOffsets.size()); 1561 Stream.EmitRecordWithBlob(SLocFileOffsetsAbbrev, Record, 1562 data(SLocFileEntryOffsets)); 1563 1564 // Write the source location entry preloads array, telling the AST 1565 // reader which source locations entries it should load eagerly. 1566 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); 1567 1568 // Write the line table. It depends on remapping working, so it must come 1569 // after the source location offsets. 1570 if (SourceMgr.hasLineTable()) { 1571 LineTableInfo &LineTable = SourceMgr.getLineTable(); 1572 1573 Record.clear(); 1574 // Emit the file names 1575 Record.push_back(LineTable.getNumFilenames()); 1576 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) { 1577 // Emit the file name 1578 const char *Filename = LineTable.getFilename(I); 1579 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1580 unsigned FilenameLen = Filename? strlen(Filename) : 0; 1581 Record.push_back(FilenameLen); 1582 if (FilenameLen) 1583 Record.insert(Record.end(), Filename, Filename + FilenameLen); 1584 } 1585 1586 // Emit the line entries 1587 for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); 1588 L != LEnd; ++L) { 1589 // Only emit entries for local files. 1590 if (L->first < 0) 1591 continue; 1592 1593 // Emit the file ID 1594 Record.push_back(L->first); 1595 1596 // Emit the line entries 1597 Record.push_back(L->second.size()); 1598 for (std::vector<LineEntry>::iterator LE = L->second.begin(), 1599 LEEnd = L->second.end(); 1600 LE != LEEnd; ++LE) { 1601 Record.push_back(LE->FileOffset); 1602 Record.push_back(LE->LineNo); 1603 Record.push_back(LE->FilenameID); 1604 Record.push_back((unsigned)LE->FileKind); 1605 Record.push_back(LE->IncludeOffset); 1606 } 1607 } 1608 Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record); 1609 } 1610} 1611 1612//===----------------------------------------------------------------------===// 1613// Preprocessor Serialization 1614//===----------------------------------------------------------------------===// 1615 1616static int compareMacroDefinitions(const void *XPtr, const void *YPtr) { 1617 const std::pair<const IdentifierInfo *, MacroInfo *> &X = 1618 *(const std::pair<const IdentifierInfo *, MacroInfo *>*)XPtr; 1619 const std::pair<const IdentifierInfo *, MacroInfo *> &Y = 1620 *(const std::pair<const IdentifierInfo *, MacroInfo *>*)YPtr; 1621 return X.first->getName().compare(Y.first->getName()); 1622} 1623 1624/// \brief Writes the block containing the serialized form of the 1625/// preprocessor. 1626/// 1627void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { 1628 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 1629 if (PPRec) 1630 WritePreprocessorDetail(*PPRec); 1631 1632 RecordData Record; 1633 1634 // If the preprocessor __COUNTER__ value has been bumped, remember it. 1635 if (PP.getCounterValue() != 0) { 1636 Record.push_back(PP.getCounterValue()); 1637 Stream.EmitRecord(PP_COUNTER_VALUE, Record); 1638 Record.clear(); 1639 } 1640 1641 // Enter the preprocessor block. 1642 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); 1643 1644 // If the AST file contains __DATE__ or __TIME__ emit a warning about this. 1645 // FIXME: use diagnostics subsystem for localization etc. 1646 if (PP.SawDateOrTime()) 1647 fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); 1648 1649 1650 // Loop over all the macro definitions that are live at the end of the file, 1651 // emitting each to the PP section. 1652 1653 // Construct the list of macro definitions that need to be serialized. 1654 SmallVector<std::pair<const IdentifierInfo *, MacroInfo *>, 2> 1655 MacrosToEmit; 1656 llvm::SmallPtrSet<const IdentifierInfo*, 4> MacroDefinitionsSeen; 1657 for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0), 1658 E = PP.macro_end(Chain == 0); 1659 I != E; ++I) { 1660 if (!IsModule || I->second->isPublic()) { 1661 MacroDefinitionsSeen.insert(I->first); 1662 MacrosToEmit.push_back(std::make_pair(I->first, I->second)); 1663 } 1664 } 1665 1666 // Sort the set of macro definitions that need to be serialized by the 1667 // name of the macro, to provide a stable ordering. 1668 llvm::array_pod_sort(MacrosToEmit.begin(), MacrosToEmit.end(), 1669 &compareMacroDefinitions); 1670 1671 // Resolve any identifiers that defined macros at the time they were 1672 // deserialized, adding them to the list of macros to emit (if appropriate). 1673 for (unsigned I = 0, N = DeserializedMacroNames.size(); I != N; ++I) { 1674 IdentifierInfo *Name 1675 = const_cast<IdentifierInfo *>(DeserializedMacroNames[I]); 1676 if (Name->hasMacroDefinition() && MacroDefinitionsSeen.insert(Name)) 1677 MacrosToEmit.push_back(std::make_pair(Name, PP.getMacroInfo(Name))); 1678 } 1679 1680 for (unsigned I = 0, N = MacrosToEmit.size(); I != N; ++I) { 1681 const IdentifierInfo *Name = MacrosToEmit[I].first; 1682 MacroInfo *MI = MacrosToEmit[I].second; 1683 if (!MI) 1684 continue; 1685 1686 // Don't emit builtin macros like __LINE__ to the AST file unless they have 1687 // been redefined by the header (in which case they are not isBuiltinMacro). 1688 // Also skip macros from a AST file if we're chaining. 1689 1690 // FIXME: There is a (probably minor) optimization we could do here, if 1691 // the macro comes from the original PCH but the identifier comes from a 1692 // chained PCH, by storing the offset into the original PCH rather than 1693 // writing the macro definition a second time. 1694 if (MI->isBuiltinMacro() || 1695 (Chain && 1696 Name->isFromAST() && !Name->hasChangedSinceDeserialization() && 1697 MI->isFromAST() && !MI->hasChangedAfterLoad())) 1698 continue; 1699 1700 AddIdentifierRef(Name, Record); 1701 MacroOffsets[Name] = Stream.GetCurrentBitNo(); 1702 Record.push_back(MI->getDefinitionLoc().getRawEncoding()); 1703 Record.push_back(MI->isUsed()); 1704 Record.push_back(MI->isPublic()); 1705 AddSourceLocation(MI->getVisibilityLocation(), Record); 1706 unsigned Code; 1707 if (MI->isObjectLike()) { 1708 Code = PP_MACRO_OBJECT_LIKE; 1709 } else { 1710 Code = PP_MACRO_FUNCTION_LIKE; 1711 1712 Record.push_back(MI->isC99Varargs()); 1713 Record.push_back(MI->isGNUVarargs()); 1714 Record.push_back(MI->getNumArgs()); 1715 for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end(); 1716 I != E; ++I) 1717 AddIdentifierRef(*I, Record); 1718 } 1719 1720 // If we have a detailed preprocessing record, record the macro definition 1721 // ID that corresponds to this macro. 1722 if (PPRec) 1723 Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]); 1724 1725 Stream.EmitRecord(Code, Record); 1726 Record.clear(); 1727 1728 // Emit the tokens array. 1729 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { 1730 // Note that we know that the preprocessor does not have any annotation 1731 // tokens in it because they are created by the parser, and thus can't be 1732 // in a macro definition. 1733 const Token &Tok = MI->getReplacementToken(TokNo); 1734 1735 Record.push_back(Tok.getLocation().getRawEncoding()); 1736 Record.push_back(Tok.getLength()); 1737 1738 // FIXME: When reading literal tokens, reconstruct the literal pointer if 1739 // it is needed. 1740 AddIdentifierRef(Tok.getIdentifierInfo(), Record); 1741 // FIXME: Should translate token kind to a stable encoding. 1742 Record.push_back(Tok.getKind()); 1743 // FIXME: Should translate token flags to a stable encoding. 1744 Record.push_back(Tok.getFlags()); 1745 1746 Stream.EmitRecord(PP_TOKEN, Record); 1747 Record.clear(); 1748 } 1749 ++NumMacros; 1750 } 1751 Stream.ExitBlock(); 1752} 1753 1754void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { 1755 if (PPRec.local_begin() == PPRec.local_end()) 1756 return; 1757 1758 SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets; 1759 1760 // Enter the preprocessor block. 1761 Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); 1762 1763 // If the preprocessor has a preprocessing record, emit it. 1764 unsigned NumPreprocessingRecords = 0; 1765 using namespace llvm; 1766 1767 // Set up the abbreviation for 1768 unsigned InclusionAbbrev = 0; 1769 { 1770 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1771 Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); 1772 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length 1773 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes 1774 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind 1775 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1776 InclusionAbbrev = Stream.EmitAbbrev(Abbrev); 1777 } 1778 1779 unsigned FirstPreprocessorEntityID 1780 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) 1781 + NUM_PREDEF_PP_ENTITY_IDS; 1782 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; 1783 RecordData Record; 1784 for (PreprocessingRecord::iterator E = PPRec.local_begin(), 1785 EEnd = PPRec.local_end(); 1786 E != EEnd; 1787 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { 1788 Record.clear(); 1789 1790 PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(), 1791 Stream.GetCurrentBitNo())); 1792 1793 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) { 1794 // Record this macro definition's ID. 1795 MacroDefinitions[MD] = NextPreprocessorEntityID; 1796 1797 AddIdentifierRef(MD->getName(), Record); 1798 Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); 1799 continue; 1800 } 1801 1802 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(*E)) { 1803 Record.push_back(ME->isBuiltinMacro()); 1804 if (ME->isBuiltinMacro()) 1805 AddIdentifierRef(ME->getName(), Record); 1806 else 1807 Record.push_back(MacroDefinitions[ME->getDefinition()]); 1808 Stream.EmitRecord(PPD_MACRO_EXPANSION, Record); 1809 continue; 1810 } 1811 1812 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) { 1813 Record.push_back(PPD_INCLUSION_DIRECTIVE); 1814 Record.push_back(ID->getFileName().size()); 1815 Record.push_back(ID->wasInQuotes()); 1816 Record.push_back(static_cast<unsigned>(ID->getKind())); 1817 llvm::SmallString<64> Buffer; 1818 Buffer += ID->getFileName(); 1819 Buffer += ID->getFile()->getName(); 1820 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); 1821 continue; 1822 } 1823 1824 llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); 1825 } 1826 Stream.ExitBlock(); 1827 1828 // Write the offsets table for the preprocessing record. 1829 if (NumPreprocessingRecords > 0) { 1830 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords); 1831 1832 // Write the offsets table for identifier IDs. 1833 using namespace llvm; 1834 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1835 Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS)); 1836 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity 1837 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1838 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1839 1840 Record.clear(); 1841 Record.push_back(PPD_ENTITIES_OFFSETS); 1842 Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS); 1843 Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, 1844 data(PreprocessedEntityOffsets)); 1845 } 1846} 1847 1848/// \brief Compute the number of modules within the given tree (including the 1849/// given module). 1850static unsigned getNumberOfModules(Module *Mod) { 1851 unsigned ChildModules = 0; 1852 for (llvm::StringMap<Module *>::iterator Sub = Mod->SubModules.begin(), 1853 SubEnd = Mod->SubModules.end(); 1854 Sub != SubEnd; ++Sub) 1855 ChildModules += getNumberOfModules(Sub->getValue()); 1856 1857 return ChildModules + 1; 1858} 1859 1860void ASTWriter::WriteSubmodules(Module *WritingModule) { 1861 // Determine the dependencies of our module and each of it's submodules. 1862 // FIXME: This feels like it belongs somewhere else, but there are no 1863 // other consumers of this information. 1864 SourceManager &SrcMgr = PP->getSourceManager(); 1865 ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); 1866 for (ASTContext::import_iterator I = Context->local_import_begin(), 1867 IEnd = Context->local_import_end(); 1868 I != IEnd; ++I) { 1869 assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); 1870 if (Module *ImportedFrom 1871 = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(), 1872 SrcMgr))) { 1873 ImportedFrom->Imports.push_back(I->getImportedModule()); 1874 } 1875 } 1876 1877 // Enter the submodule description block. 1878 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); 1879 1880 // Write the abbreviations needed for the submodules block. 1881 using namespace llvm; 1882 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1883 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); 1884 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent 1885 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework 1886 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit 1887 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 1888 unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev); 1889 1890 Abbrev = new BitCodeAbbrev(); 1891 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA)); 1892 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 1893 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev); 1894 1895 Abbrev = new BitCodeAbbrev(); 1896 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); 1897 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 1898 unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev); 1899 1900 // Write the submodule metadata block. 1901 RecordData Record; 1902 Record.push_back(getNumberOfModules(WritingModule)); 1903 Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS); 1904 Stream.EmitRecord(SUBMODULE_METADATA, Record); 1905 1906 // Write all of the submodules. 1907 std::queue<Module *> Q; 1908 Q.push(WritingModule); 1909 while (!Q.empty()) { 1910 Module *Mod = Q.front(); 1911 Q.pop(); 1912 assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); 1913 SubmoduleIDs[Mod] = NextSubmoduleID++; 1914 1915 // Emit the definition of the block. 1916 Record.clear(); 1917 Record.push_back(SUBMODULE_DEFINITION); 1918 if (Mod->Parent) { 1919 assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); 1920 Record.push_back(SubmoduleIDs[Mod->Parent]); 1921 } else { 1922 Record.push_back(0); 1923 } 1924 Record.push_back(Mod->IsFramework); 1925 Record.push_back(Mod->IsExplicit); 1926 Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); 1927 1928 // Emit the umbrella header, if there is one. 1929 if (Mod->UmbrellaHeader) { 1930 Record.clear(); 1931 Record.push_back(SUBMODULE_UMBRELLA); 1932 Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, 1933 Mod->UmbrellaHeader->getName()); 1934 } 1935 1936 // Emit the headers. 1937 for (unsigned I = 0, N = Mod->Headers.size(); I != N; ++I) { 1938 Record.clear(); 1939 Record.push_back(SUBMODULE_HEADER); 1940 Stream.EmitRecordWithBlob(HeaderAbbrev, Record, 1941 Mod->Headers[I]->getName()); 1942 } 1943 1944 // Emit the imports. 1945 if (!Mod->Imports.empty()) { 1946 Record.clear(); 1947 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { 1948 unsigned ImportedID = SubmoduleIDs[Mod->Imports[I]]; 1949 assert(ImportedID && "Unknown submodule!"); 1950 Record.push_back(ImportedID); 1951 } 1952 Stream.EmitRecord(SUBMODULE_IMPORTS, Record); 1953 } 1954 1955 // Emit the exports. 1956 if (!Mod->Exports.empty()) { 1957 Record.clear(); 1958 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { 1959 unsigned ExportedID = SubmoduleIDs[Mod->Exports[I].getPointer()]; 1960 assert(ExportedID && "Unknown submodule!"); 1961 Record.push_back(ExportedID); 1962 Record.push_back(Mod->Exports[I].getInt()); 1963 } 1964 Stream.EmitRecord(SUBMODULE_EXPORTS, Record); 1965 } 1966 1967 // Queue up the submodules of this module. 1968 llvm::SmallVector<StringRef, 2> SubModules; 1969 1970 // Sort the submodules first, so we get a predictable ordering in the AST 1971 // file. 1972 for (llvm::StringMap<Module *>::iterator 1973 Sub = Mod->SubModules.begin(), 1974 SubEnd = Mod->SubModules.end(); 1975 Sub != SubEnd; ++Sub) 1976 SubModules.push_back(Sub->getKey()); 1977 llvm::array_pod_sort(SubModules.begin(), SubModules.end()); 1978 1979 for (unsigned I = 0, N = SubModules.size(); I != N; ++I) 1980 Q.push(Mod->SubModules[SubModules[I]]); 1981 } 1982 1983 Stream.ExitBlock(); 1984} 1985 1986serialization::SubmoduleID 1987ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) { 1988 if (Loc.isInvalid() || SubmoduleIDs.empty()) 1989 return 0; // No submodule 1990 1991 // Find the module that owns this location. 1992 ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); 1993 Module *OwningMod 1994 = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager())); 1995 if (!OwningMod) 1996 return 0; 1997 1998 // Check whether we known about this submodule. 1999 llvm::DenseMap<Module *, unsigned>::iterator Known 2000 = SubmoduleIDs.find(OwningMod); 2001 if (Known == SubmoduleIDs.end()) 2002 return 0; 2003 2004 return Known->second; 2005} 2006 2007void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag) { 2008 RecordData Record; 2009 for (DiagnosticsEngine::DiagStatePointsTy::const_iterator 2010 I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end(); 2011 I != E; ++I) { 2012 const DiagnosticsEngine::DiagStatePoint &point = *I; 2013 if (point.Loc.isInvalid()) 2014 continue; 2015 2016 Record.push_back(point.Loc.getRawEncoding()); 2017 for (DiagnosticsEngine::DiagState::const_iterator 2018 I = point.State->begin(), E = point.State->end(); I != E; ++I) { 2019 if (I->second.isPragma()) { 2020 Record.push_back(I->first); 2021 Record.push_back(I->second.getMapping()); 2022 } 2023 } 2024 Record.push_back(-1); // mark the end of the diag/map pairs for this 2025 // location. 2026 } 2027 2028 if (!Record.empty()) 2029 Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); 2030} 2031 2032void ASTWriter::WriteCXXBaseSpecifiersOffsets() { 2033 if (CXXBaseSpecifiersOffsets.empty()) 2034 return; 2035 2036 RecordData Record; 2037 2038 // Create a blob abbreviation for the C++ base specifiers offsets. 2039 using namespace llvm; 2040 2041 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2042 Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS)); 2043 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 2044 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2045 unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2046 2047 // Write the base specifier offsets table. 2048 Record.clear(); 2049 Record.push_back(CXX_BASE_SPECIFIER_OFFSETS); 2050 Record.push_back(CXXBaseSpecifiersOffsets.size()); 2051 Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record, 2052 data(CXXBaseSpecifiersOffsets)); 2053} 2054 2055//===----------------------------------------------------------------------===// 2056// Type Serialization 2057//===----------------------------------------------------------------------===// 2058 2059/// \brief Write the representation of a type to the AST stream. 2060void ASTWriter::WriteType(QualType T) { 2061 TypeIdx &Idx = TypeIdxs[T]; 2062 if (Idx.getIndex() == 0) // we haven't seen this type before. 2063 Idx = TypeIdx(NextTypeID++); 2064 2065 assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); 2066 2067 // Record the offset for this type. 2068 unsigned Index = Idx.getIndex() - FirstTypeID; 2069 if (TypeOffsets.size() == Index) 2070 TypeOffsets.push_back(Stream.GetCurrentBitNo()); 2071 else if (TypeOffsets.size() < Index) { 2072 TypeOffsets.resize(Index + 1); 2073 TypeOffsets[Index] = Stream.GetCurrentBitNo(); 2074 } 2075 2076 RecordData Record; 2077 2078 // Emit the type's representation. 2079 ASTTypeWriter W(*this, Record); 2080 2081 if (T.hasLocalNonFastQualifiers()) { 2082 Qualifiers Qs = T.getLocalQualifiers(); 2083 AddTypeRef(T.getLocalUnqualifiedType(), Record); 2084 Record.push_back(Qs.getAsOpaqueValue()); 2085 W.Code = TYPE_EXT_QUAL; 2086 } else { 2087 switch (T->getTypeClass()) { 2088 // For all of the concrete, non-dependent types, call the 2089 // appropriate visitor function. 2090#define TYPE(Class, Base) \ 2091 case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break; 2092#define ABSTRACT_TYPE(Class, Base) 2093#include "clang/AST/TypeNodes.def" 2094 } 2095 } 2096 2097 // Emit the serialized record. 2098 Stream.EmitRecord(W.Code, Record); 2099 2100 // Flush any expressions that were written as part of this type. 2101 FlushStmts(); 2102} 2103 2104//===----------------------------------------------------------------------===// 2105// Declaration Serialization 2106//===----------------------------------------------------------------------===// 2107 2108/// \brief Write the block containing all of the declaration IDs 2109/// lexically declared within the given DeclContext. 2110/// 2111/// \returns the offset of the DECL_CONTEXT_LEXICAL block within the 2112/// bistream, or 0 if no block was written. 2113uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, 2114 DeclContext *DC) { 2115 if (DC->decls_empty()) 2116 return 0; 2117 2118 uint64_t Offset = Stream.GetCurrentBitNo(); 2119 RecordData Record; 2120 Record.push_back(DECL_CONTEXT_LEXICAL); 2121 SmallVector<KindDeclIDPair, 64> Decls; 2122 for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end(); 2123 D != DEnd; ++D) 2124 Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D))); 2125 2126 ++NumLexicalDeclContexts; 2127 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls)); 2128 return Offset; 2129} 2130 2131void ASTWriter::WriteTypeDeclOffsets() { 2132 using namespace llvm; 2133 RecordData Record; 2134 2135 // Write the type offsets array 2136 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2137 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); 2138 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types 2139 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index 2140 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block 2141 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2142 Record.clear(); 2143 Record.push_back(TYPE_OFFSET); 2144 Record.push_back(TypeOffsets.size()); 2145 Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS); 2146 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets)); 2147 2148 // Write the declaration offsets array 2149 Abbrev = new BitCodeAbbrev(); 2150 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); 2151 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations 2152 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID 2153 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block 2154 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2155 Record.clear(); 2156 Record.push_back(DECL_OFFSET); 2157 Record.push_back(DeclOffsets.size()); 2158 Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS); 2159 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets)); 2160} 2161 2162void ASTWriter::WriteFileDeclIDsMap() { 2163 using namespace llvm; 2164 RecordData Record; 2165 2166 // Join the vectors of DeclIDs from all files. 2167 SmallVector<DeclID, 256> FileSortedIDs; 2168 for (FileDeclIDsTy::iterator 2169 FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) { 2170 DeclIDInFileInfo &Info = *FI->second; 2171 Info.FirstDeclIndex = FileSortedIDs.size(); 2172 for (LocDeclIDsTy::iterator 2173 DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI) 2174 FileSortedIDs.push_back(DI->second); 2175 } 2176 2177 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2178 Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); 2179 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2180 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 2181 Record.push_back(FILE_SORTED_DECLS); 2182 Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs)); 2183} 2184 2185//===----------------------------------------------------------------------===// 2186// Global Method Pool and Selector Serialization 2187//===----------------------------------------------------------------------===// 2188 2189namespace { 2190// Trait used for the on-disk hash table used in the method pool. 2191class ASTMethodPoolTrait { 2192 ASTWriter &Writer; 2193 2194public: 2195 typedef Selector key_type; 2196 typedef key_type key_type_ref; 2197 2198 struct data_type { 2199 SelectorID ID; 2200 ObjCMethodList Instance, Factory; 2201 }; 2202 typedef const data_type& data_type_ref; 2203 2204 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } 2205 2206 static unsigned ComputeHash(Selector Sel) { 2207 return serialization::ComputeHash(Sel); 2208 } 2209 2210 std::pair<unsigned,unsigned> 2211 EmitKeyDataLength(raw_ostream& Out, Selector Sel, 2212 data_type_ref Methods) { 2213 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); 2214 clang::io::Emit16(Out, KeyLen); 2215 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts 2216 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2217 Method = Method->Next) 2218 if (Method->Method) 2219 DataLen += 4; 2220 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2221 Method = Method->Next) 2222 if (Method->Method) 2223 DataLen += 4; 2224 clang::io::Emit16(Out, DataLen); 2225 return std::make_pair(KeyLen, DataLen); 2226 } 2227 2228 void EmitKey(raw_ostream& Out, Selector Sel, unsigned) { 2229 uint64_t Start = Out.tell(); 2230 assert((Start >> 32) == 0 && "Selector key offset too large"); 2231 Writer.SetSelectorOffset(Sel, Start); 2232 unsigned N = Sel.getNumArgs(); 2233 clang::io::Emit16(Out, N); 2234 if (N == 0) 2235 N = 1; 2236 for (unsigned I = 0; I != N; ++I) 2237 clang::io::Emit32(Out, 2238 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); 2239 } 2240 2241 void EmitData(raw_ostream& Out, key_type_ref, 2242 data_type_ref Methods, unsigned DataLen) { 2243 uint64_t Start = Out.tell(); (void)Start; 2244 clang::io::Emit32(Out, Methods.ID); 2245 unsigned NumInstanceMethods = 0; 2246 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2247 Method = Method->Next) 2248 if (Method->Method) 2249 ++NumInstanceMethods; 2250 2251 unsigned NumFactoryMethods = 0; 2252 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2253 Method = Method->Next) 2254 if (Method->Method) 2255 ++NumFactoryMethods; 2256 2257 clang::io::Emit16(Out, NumInstanceMethods); 2258 clang::io::Emit16(Out, NumFactoryMethods); 2259 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2260 Method = Method->Next) 2261 if (Method->Method) 2262 clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 2263 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2264 Method = Method->Next) 2265 if (Method->Method) 2266 clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 2267 2268 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 2269 } 2270}; 2271} // end anonymous namespace 2272 2273/// \brief Write ObjC data: selectors and the method pool. 2274/// 2275/// The method pool contains both instance and factory methods, stored 2276/// in an on-disk hash table indexed by the selector. The hash table also 2277/// contains an empty entry for every other selector known to Sema. 2278void ASTWriter::WriteSelectors(Sema &SemaRef) { 2279 using namespace llvm; 2280 2281 // Do we have to do anything at all? 2282 if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) 2283 return; 2284 unsigned NumTableEntries = 0; 2285 // Create and write out the blob that contains selectors and the method pool. 2286 { 2287 OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator; 2288 ASTMethodPoolTrait Trait(*this); 2289 2290 // Create the on-disk hash table representation. We walk through every 2291 // selector we've seen and look it up in the method pool. 2292 SelectorOffsets.resize(NextSelectorID - FirstSelectorID); 2293 for (llvm::DenseMap<Selector, SelectorID>::iterator 2294 I = SelectorIDs.begin(), E = SelectorIDs.end(); 2295 I != E; ++I) { 2296 Selector S = I->first; 2297 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); 2298 ASTMethodPoolTrait::data_type Data = { 2299 I->second, 2300 ObjCMethodList(), 2301 ObjCMethodList() 2302 }; 2303 if (F != SemaRef.MethodPool.end()) { 2304 Data.Instance = F->second.first; 2305 Data.Factory = F->second.second; 2306 } 2307 // Only write this selector if it's not in an existing AST or something 2308 // changed. 2309 if (Chain && I->second < FirstSelectorID) { 2310 // Selector already exists. Did it change? 2311 bool changed = false; 2312 for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method; 2313 M = M->Next) { 2314 if (!M->Method->isFromASTFile()) 2315 changed = true; 2316 } 2317 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method; 2318 M = M->Next) { 2319 if (!M->Method->isFromASTFile()) 2320 changed = true; 2321 } 2322 if (!changed) 2323 continue; 2324 } else if (Data.Instance.Method || Data.Factory.Method) { 2325 // A new method pool entry. 2326 ++NumTableEntries; 2327 } 2328 Generator.insert(S, Data, Trait); 2329 } 2330 2331 // Create the on-disk hash table in a buffer. 2332 llvm::SmallString<4096> MethodPool; 2333 uint32_t BucketOffset; 2334 { 2335 ASTMethodPoolTrait Trait(*this); 2336 llvm::raw_svector_ostream Out(MethodPool); 2337 // Make sure that no bucket is at offset 0 2338 clang::io::Emit32(Out, 0); 2339 BucketOffset = Generator.Emit(Out, Trait); 2340 } 2341 2342 // Create a blob abbreviation 2343 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2344 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); 2345 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2346 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2347 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2348 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); 2349 2350 // Write the method pool 2351 RecordData Record; 2352 Record.push_back(METHOD_POOL); 2353 Record.push_back(BucketOffset); 2354 Record.push_back(NumTableEntries); 2355 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str()); 2356 2357 // Create a blob abbreviation for the selector table offsets. 2358 Abbrev = new BitCodeAbbrev(); 2359 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); 2360 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 2361 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 2362 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2363 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2364 2365 // Write the selector offsets table. 2366 Record.clear(); 2367 Record.push_back(SELECTOR_OFFSETS); 2368 Record.push_back(SelectorOffsets.size()); 2369 Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS); 2370 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, 2371 data(SelectorOffsets)); 2372 } 2373} 2374 2375/// \brief Write the selectors referenced in @selector expression into AST file. 2376void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { 2377 using namespace llvm; 2378 if (SemaRef.ReferencedSelectors.empty()) 2379 return; 2380 2381 RecordData Record; 2382 2383 // Note: this writes out all references even for a dependent AST. But it is 2384 // very tricky to fix, and given that @selector shouldn't really appear in 2385 // headers, probably not worth it. It's not a correctness issue. 2386 for (DenseMap<Selector, SourceLocation>::iterator S = 2387 SemaRef.ReferencedSelectors.begin(), 2388 E = SemaRef.ReferencedSelectors.end(); S != E; ++S) { 2389 Selector Sel = (*S).first; 2390 SourceLocation Loc = (*S).second; 2391 AddSelectorRef(Sel, Record); 2392 AddSourceLocation(Loc, Record); 2393 } 2394 Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record); 2395} 2396 2397//===----------------------------------------------------------------------===// 2398// Identifier Table Serialization 2399//===----------------------------------------------------------------------===// 2400 2401namespace { 2402class ASTIdentifierTableTrait { 2403 ASTWriter &Writer; 2404 Preprocessor &PP; 2405 IdentifierResolver &IdResolver; 2406 bool IsModule; 2407 2408 /// \brief Determines whether this is an "interesting" identifier 2409 /// that needs a full IdentifierInfo structure written into the hash 2410 /// table. 2411 bool isInterestingIdentifier(IdentifierInfo *II, MacroInfo *&Macro) { 2412 if (II->isPoisoned() || 2413 II->isExtensionToken() || 2414 II->getObjCOrBuiltinID() || 2415 II->hasRevertedTokenIDToIdentifier() || 2416 II->getFETokenInfo<void>()) 2417 return true; 2418 2419 return hasMacroDefinition(II, Macro); 2420 } 2421 2422 bool hasMacroDefinition(IdentifierInfo *II, MacroInfo *&Macro) { 2423 if (!II->hasMacroDefinition()) 2424 return false; 2425 2426 if (Macro || (Macro = PP.getMacroInfo(II))) 2427 return !Macro->isBuiltinMacro() && (!IsModule || Macro->isPublic()); 2428 2429 return false; 2430 } 2431 2432public: 2433 typedef IdentifierInfo* key_type; 2434 typedef key_type key_type_ref; 2435 2436 typedef IdentID data_type; 2437 typedef data_type data_type_ref; 2438 2439 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, 2440 IdentifierResolver &IdResolver, bool IsModule) 2441 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { } 2442 2443 static unsigned ComputeHash(const IdentifierInfo* II) { 2444 return llvm::HashString(II->getName()); 2445 } 2446 2447 std::pair<unsigned,unsigned> 2448 EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { 2449 unsigned KeyLen = II->getLength() + 1; 2450 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 2451 MacroInfo *Macro = 0; 2452 if (isInterestingIdentifier(II, Macro)) { 2453 DataLen += 2; // 2 bytes for builtin ID, flags 2454 if (hasMacroDefinition(II, Macro)) 2455 DataLen += 8; 2456 2457 for (IdentifierResolver::iterator D = IdResolver.begin(II), 2458 DEnd = IdResolver.end(); 2459 D != DEnd; ++D) 2460 DataLen += sizeof(DeclID); 2461 } 2462 clang::io::Emit16(Out, DataLen); 2463 // We emit the key length after the data length so that every 2464 // string is preceded by a 16-bit length. This matches the PTH 2465 // format for storing identifiers. 2466 clang::io::Emit16(Out, KeyLen); 2467 return std::make_pair(KeyLen, DataLen); 2468 } 2469 2470 void EmitKey(raw_ostream& Out, const IdentifierInfo* II, 2471 unsigned KeyLen) { 2472 // Record the location of the key data. This is used when generating 2473 // the mapping from persistent IDs to strings. 2474 Writer.SetIdentifierOffset(II, Out.tell()); 2475 Out.write(II->getNameStart(), KeyLen); 2476 } 2477 2478 void EmitData(raw_ostream& Out, IdentifierInfo* II, 2479 IdentID ID, unsigned) { 2480 MacroInfo *Macro = 0; 2481 if (!isInterestingIdentifier(II, Macro)) { 2482 clang::io::Emit32(Out, ID << 1); 2483 return; 2484 } 2485 2486 clang::io::Emit32(Out, (ID << 1) | 0x01); 2487 uint32_t Bits = 0; 2488 bool HasMacroDefinition = hasMacroDefinition(II, Macro); 2489 Bits = (uint32_t)II->getObjCOrBuiltinID(); 2490 Bits = (Bits << 1) | unsigned(HasMacroDefinition); 2491 Bits = (Bits << 1) | unsigned(II->isExtensionToken()); 2492 Bits = (Bits << 1) | unsigned(II->isPoisoned()); 2493 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); 2494 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); 2495 clang::io::Emit16(Out, Bits); 2496 2497 if (HasMacroDefinition) { 2498 clang::io::Emit32(Out, Writer.getMacroOffset(II)); 2499 clang::io::Emit32(Out, 2500 Writer.inferSubmoduleIDFromLocation(Macro->getDefinitionLoc())); 2501 } 2502 2503 // Emit the declaration IDs in reverse order, because the 2504 // IdentifierResolver provides the declarations as they would be 2505 // visible (e.g., the function "stat" would come before the struct 2506 // "stat"), but the ASTReader adds declarations to the end of the list 2507 // (so we need to see the struct "status" before the function "status"). 2508 // Only emit declarations that aren't from a chained PCH, though. 2509 SmallVector<Decl *, 16> Decls(IdResolver.begin(II), 2510 IdResolver.end()); 2511 for (SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(), 2512 DEnd = Decls.rend(); 2513 D != DEnd; ++D) 2514 clang::io::Emit32(Out, Writer.getDeclID(*D)); 2515 } 2516}; 2517} // end anonymous namespace 2518 2519/// \brief Write the identifier table into the AST file. 2520/// 2521/// The identifier table consists of a blob containing string data 2522/// (the actual identifiers themselves) and a separate "offsets" index 2523/// that maps identifier IDs to locations within the blob. 2524void ASTWriter::WriteIdentifierTable(Preprocessor &PP, 2525 IdentifierResolver &IdResolver, 2526 bool IsModule) { 2527 using namespace llvm; 2528 2529 // Create and write out the blob that contains the identifier 2530 // strings. 2531 { 2532 OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator; 2533 ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); 2534 2535 // Look for any identifiers that were named while processing the 2536 // headers, but are otherwise not needed. We add these to the hash 2537 // table to enable checking of the predefines buffer in the case 2538 // where the user adds new macro definitions when building the AST 2539 // file. 2540 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), 2541 IDEnd = PP.getIdentifierTable().end(); 2542 ID != IDEnd; ++ID) 2543 getIdentifierRef(ID->second); 2544 2545 // Create the on-disk hash table representation. We only store offsets 2546 // for identifiers that appear here for the first time. 2547 IdentifierOffsets.resize(NextIdentID - FirstIdentID); 2548 for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator 2549 ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); 2550 ID != IDEnd; ++ID) { 2551 assert(ID->first && "NULL identifier in identifier table"); 2552 if (!Chain || !ID->first->isFromAST() || 2553 ID->first->hasChangedSinceDeserialization()) 2554 Generator.insert(const_cast<IdentifierInfo *>(ID->first), ID->second, 2555 Trait); 2556 } 2557 2558 // Create the on-disk hash table in a buffer. 2559 llvm::SmallString<4096> IdentifierTable; 2560 uint32_t BucketOffset; 2561 { 2562 ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); 2563 llvm::raw_svector_ostream Out(IdentifierTable); 2564 // Make sure that no bucket is at offset 0 2565 clang::io::Emit32(Out, 0); 2566 BucketOffset = Generator.Emit(Out, Trait); 2567 } 2568 2569 // Create a blob abbreviation 2570 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2571 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); 2572 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2573 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2574 unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); 2575 2576 // Write the identifier table 2577 RecordData Record; 2578 Record.push_back(IDENTIFIER_TABLE); 2579 Record.push_back(BucketOffset); 2580 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str()); 2581 } 2582 2583 // Write the offsets table for identifier IDs. 2584 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2585 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); 2586 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers 2587 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 2588 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2589 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2590 2591 RecordData Record; 2592 Record.push_back(IDENTIFIER_OFFSET); 2593 Record.push_back(IdentifierOffsets.size()); 2594 Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS); 2595 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, 2596 data(IdentifierOffsets)); 2597} 2598 2599//===----------------------------------------------------------------------===// 2600// DeclContext's Name Lookup Table Serialization 2601//===----------------------------------------------------------------------===// 2602 2603namespace { 2604// Trait used for the on-disk hash table used in the method pool. 2605class ASTDeclContextNameLookupTrait { 2606 ASTWriter &Writer; 2607 2608public: 2609 typedef DeclarationName key_type; 2610 typedef key_type key_type_ref; 2611 2612 typedef DeclContext::lookup_result data_type; 2613 typedef const data_type& data_type_ref; 2614 2615 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { } 2616 2617 unsigned ComputeHash(DeclarationName Name) { 2618 llvm::FoldingSetNodeID ID; 2619 ID.AddInteger(Name.getNameKind()); 2620 2621 switch (Name.getNameKind()) { 2622 case DeclarationName::Identifier: 2623 ID.AddString(Name.getAsIdentifierInfo()->getName()); 2624 break; 2625 case DeclarationName::ObjCZeroArgSelector: 2626 case DeclarationName::ObjCOneArgSelector: 2627 case DeclarationName::ObjCMultiArgSelector: 2628 ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector())); 2629 break; 2630 case DeclarationName::CXXConstructorName: 2631 case DeclarationName::CXXDestructorName: 2632 case DeclarationName::CXXConversionFunctionName: 2633 break; 2634 case DeclarationName::CXXOperatorName: 2635 ID.AddInteger(Name.getCXXOverloadedOperator()); 2636 break; 2637 case DeclarationName::CXXLiteralOperatorName: 2638 ID.AddString(Name.getCXXLiteralIdentifier()->getName()); 2639 case DeclarationName::CXXUsingDirective: 2640 break; 2641 } 2642 2643 return ID.ComputeHash(); 2644 } 2645 2646 std::pair<unsigned,unsigned> 2647 EmitKeyDataLength(raw_ostream& Out, DeclarationName Name, 2648 data_type_ref Lookup) { 2649 unsigned KeyLen = 1; 2650 switch (Name.getNameKind()) { 2651 case DeclarationName::Identifier: 2652 case DeclarationName::ObjCZeroArgSelector: 2653 case DeclarationName::ObjCOneArgSelector: 2654 case DeclarationName::ObjCMultiArgSelector: 2655 case DeclarationName::CXXLiteralOperatorName: 2656 KeyLen += 4; 2657 break; 2658 case DeclarationName::CXXOperatorName: 2659 KeyLen += 1; 2660 break; 2661 case DeclarationName::CXXConstructorName: 2662 case DeclarationName::CXXDestructorName: 2663 case DeclarationName::CXXConversionFunctionName: 2664 case DeclarationName::CXXUsingDirective: 2665 break; 2666 } 2667 clang::io::Emit16(Out, KeyLen); 2668 2669 // 2 bytes for num of decls and 4 for each DeclID. 2670 unsigned DataLen = 2 + 4 * (Lookup.second - Lookup.first); 2671 clang::io::Emit16(Out, DataLen); 2672 2673 return std::make_pair(KeyLen, DataLen); 2674 } 2675 2676 void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) { 2677 using namespace clang::io; 2678 2679 assert(Name.getNameKind() < 0x100 && "Invalid name kind ?"); 2680 Emit8(Out, Name.getNameKind()); 2681 switch (Name.getNameKind()) { 2682 case DeclarationName::Identifier: 2683 Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo())); 2684 break; 2685 case DeclarationName::ObjCZeroArgSelector: 2686 case DeclarationName::ObjCOneArgSelector: 2687 case DeclarationName::ObjCMultiArgSelector: 2688 Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector())); 2689 break; 2690 case DeclarationName::CXXOperatorName: 2691 assert(Name.getCXXOverloadedOperator() < 0x100 && "Invalid operator ?"); 2692 Emit8(Out, Name.getCXXOverloadedOperator()); 2693 break; 2694 case DeclarationName::CXXLiteralOperatorName: 2695 Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); 2696 break; 2697 case DeclarationName::CXXConstructorName: 2698 case DeclarationName::CXXDestructorName: 2699 case DeclarationName::CXXConversionFunctionName: 2700 case DeclarationName::CXXUsingDirective: 2701 break; 2702 } 2703 } 2704 2705 void EmitData(raw_ostream& Out, key_type_ref, 2706 data_type Lookup, unsigned DataLen) { 2707 uint64_t Start = Out.tell(); (void)Start; 2708 clang::io::Emit16(Out, Lookup.second - Lookup.first); 2709 for (; Lookup.first != Lookup.second; ++Lookup.first) 2710 clang::io::Emit32(Out, Writer.GetDeclRef(*Lookup.first)); 2711 2712 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 2713 } 2714}; 2715} // end anonymous namespace 2716 2717/// \brief Write the block containing all of the declaration IDs 2718/// visible from the given DeclContext. 2719/// 2720/// \returns the offset of the DECL_CONTEXT_VISIBLE block within the 2721/// bitstream, or 0 if no block was written. 2722uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, 2723 DeclContext *DC) { 2724 if (DC->getPrimaryContext() != DC) 2725 return 0; 2726 2727 // Since there is no name lookup into functions or methods, don't bother to 2728 // build a visible-declarations table for these entities. 2729 if (DC->isFunctionOrMethod()) 2730 return 0; 2731 2732 // If not in C++, we perform name lookup for the translation unit via the 2733 // IdentifierInfo chains, don't bother to build a visible-declarations table. 2734 // FIXME: In C++ we need the visible declarations in order to "see" the 2735 // friend declarations, is there a way to do this without writing the table ? 2736 if (DC->isTranslationUnit() && !Context.getLangOptions().CPlusPlus) 2737 return 0; 2738 2739 // Force the DeclContext to build a its name-lookup table. 2740 if (!DC->hasExternalVisibleStorage()) 2741 DC->lookup(DeclarationName()); 2742 2743 // Serialize the contents of the mapping used for lookup. Note that, 2744 // although we have two very different code paths, the serialized 2745 // representation is the same for both cases: a declaration name, 2746 // followed by a size, followed by references to the visible 2747 // declarations that have that name. 2748 uint64_t Offset = Stream.GetCurrentBitNo(); 2749 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); 2750 if (!Map || Map->empty()) 2751 return 0; 2752 2753 OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator; 2754 ASTDeclContextNameLookupTrait Trait(*this); 2755 2756 // Create the on-disk hash table representation. 2757 DeclarationName ConversionName; 2758 llvm::SmallVector<NamedDecl *, 4> ConversionDecls; 2759 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 2760 D != DEnd; ++D) { 2761 DeclarationName Name = D->first; 2762 DeclContext::lookup_result Result = D->second.getLookupResult(); 2763 if (Result.first != Result.second) { 2764 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 2765 // Hash all conversion function names to the same name. The actual 2766 // type information in conversion function name is not used in the 2767 // key (since such type information is not stable across different 2768 // modules), so the intended effect is to coalesce all of the conversion 2769 // functions under a single key. 2770 if (!ConversionName) 2771 ConversionName = Name; 2772 ConversionDecls.append(Result.first, Result.second); 2773 continue; 2774 } 2775 2776 Generator.insert(Name, Result, Trait); 2777 } 2778 } 2779 2780 // Add the conversion functions 2781 if (!ConversionDecls.empty()) { 2782 Generator.insert(ConversionName, 2783 DeclContext::lookup_result(ConversionDecls.begin(), 2784 ConversionDecls.end()), 2785 Trait); 2786 } 2787 2788 // Create the on-disk hash table in a buffer. 2789 llvm::SmallString<4096> LookupTable; 2790 uint32_t BucketOffset; 2791 { 2792 llvm::raw_svector_ostream Out(LookupTable); 2793 // Make sure that no bucket is at offset 0 2794 clang::io::Emit32(Out, 0); 2795 BucketOffset = Generator.Emit(Out, Trait); 2796 } 2797 2798 // Write the lookup table 2799 RecordData Record; 2800 Record.push_back(DECL_CONTEXT_VISIBLE); 2801 Record.push_back(BucketOffset); 2802 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, 2803 LookupTable.str()); 2804 2805 Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record); 2806 ++NumVisibleDeclContexts; 2807 return Offset; 2808} 2809 2810/// \brief Write an UPDATE_VISIBLE block for the given context. 2811/// 2812/// UPDATE_VISIBLE blocks contain the declarations that are added to an existing 2813/// DeclContext in a dependent AST file. As such, they only exist for the TU 2814/// (in C++) and for namespaces. 2815void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { 2816 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); 2817 if (!Map || Map->empty()) 2818 return; 2819 2820 OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator; 2821 ASTDeclContextNameLookupTrait Trait(*this); 2822 2823 // Create the hash table. 2824 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 2825 D != DEnd; ++D) { 2826 DeclarationName Name = D->first; 2827 DeclContext::lookup_result Result = D->second.getLookupResult(); 2828 // For any name that appears in this table, the results are complete, i.e. 2829 // they overwrite results from previous PCHs. Merging is always a mess. 2830 if (Result.first != Result.second) 2831 Generator.insert(Name, Result, Trait); 2832 } 2833 2834 // Create the on-disk hash table in a buffer. 2835 llvm::SmallString<4096> LookupTable; 2836 uint32_t BucketOffset; 2837 { 2838 llvm::raw_svector_ostream Out(LookupTable); 2839 // Make sure that no bucket is at offset 0 2840 clang::io::Emit32(Out, 0); 2841 BucketOffset = Generator.Emit(Out, Trait); 2842 } 2843 2844 // Write the lookup table 2845 RecordData Record; 2846 Record.push_back(UPDATE_VISIBLE); 2847 Record.push_back(getDeclID(cast<Decl>(DC))); 2848 Record.push_back(BucketOffset); 2849 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str()); 2850} 2851 2852/// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. 2853void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { 2854 RecordData Record; 2855 Record.push_back(Opts.fp_contract); 2856 Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); 2857} 2858 2859/// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. 2860void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { 2861 if (!SemaRef.Context.getLangOptions().OpenCL) 2862 return; 2863 2864 const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); 2865 RecordData Record; 2866#define OPENCLEXT(nm) Record.push_back(Opts.nm); 2867#include "clang/Basic/OpenCLExtensions.def" 2868 Stream.EmitRecord(OPENCL_EXTENSIONS, Record); 2869} 2870 2871//===----------------------------------------------------------------------===// 2872// General Serialization Routines 2873//===----------------------------------------------------------------------===// 2874 2875/// \brief Write a record containing the given attributes. 2876void ASTWriter::WriteAttributes(const AttrVec &Attrs, RecordDataImpl &Record) { 2877 Record.push_back(Attrs.size()); 2878 for (AttrVec::const_iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){ 2879 const Attr * A = *i; 2880 Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs 2881 AddSourceRange(A->getRange(), Record); 2882 2883#include "clang/Serialization/AttrPCHWrite.inc" 2884 2885 } 2886} 2887 2888void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { 2889 Record.push_back(Str.size()); 2890 Record.insert(Record.end(), Str.begin(), Str.end()); 2891} 2892 2893void ASTWriter::AddVersionTuple(const VersionTuple &Version, 2894 RecordDataImpl &Record) { 2895 Record.push_back(Version.getMajor()); 2896 if (llvm::Optional<unsigned> Minor = Version.getMinor()) 2897 Record.push_back(*Minor + 1); 2898 else 2899 Record.push_back(0); 2900 if (llvm::Optional<unsigned> Subminor = Version.getSubminor()) 2901 Record.push_back(*Subminor + 1); 2902 else 2903 Record.push_back(0); 2904} 2905 2906/// \brief Note that the identifier II occurs at the given offset 2907/// within the identifier table. 2908void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { 2909 IdentID ID = IdentifierIDs[II]; 2910 // Only store offsets new to this AST file. Other identifier names are looked 2911 // up earlier in the chain and thus don't need an offset. 2912 if (ID >= FirstIdentID) 2913 IdentifierOffsets[ID - FirstIdentID] = Offset; 2914} 2915 2916/// \brief Note that the selector Sel occurs at the given offset 2917/// within the method pool/selector table. 2918void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { 2919 unsigned ID = SelectorIDs[Sel]; 2920 assert(ID && "Unknown selector"); 2921 // Don't record offsets for selectors that are also available in a different 2922 // file. 2923 if (ID < FirstSelectorID) 2924 return; 2925 SelectorOffsets[ID - FirstSelectorID] = Offset; 2926} 2927 2928ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) 2929 : Stream(Stream), Context(0), PP(0), Chain(0), WritingAST(false), 2930 FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), 2931 FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), 2932 FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), 2933 FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), 2934 NextSubmoduleID(FirstSubmoduleID), 2935 FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), 2936 CollectedStmts(&StmtsToEmit), 2937 NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), 2938 NumVisibleDeclContexts(0), 2939 NextCXXBaseSpecifiersID(1), 2940 DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0), 2941 DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0), 2942 DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0), 2943 DeclRecordAbbrev(0), IntegerLiteralAbbrev(0), 2944 DeclTypedefAbbrev(0), 2945 DeclVarAbbrev(0), DeclFieldAbbrev(0), 2946 DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0) 2947{ 2948} 2949 2950ASTWriter::~ASTWriter() { 2951 for (FileDeclIDsTy::iterator 2952 I = FileDeclIDs.begin(), E = FileDeclIDs.end(); I != E; ++I) 2953 delete I->second; 2954} 2955 2956void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2957 const std::string &OutputFile, 2958 Module *WritingModule, StringRef isysroot) { 2959 WritingAST = true; 2960 2961 // Emit the file header. 2962 Stream.Emit((unsigned)'C', 8); 2963 Stream.Emit((unsigned)'P', 8); 2964 Stream.Emit((unsigned)'C', 8); 2965 Stream.Emit((unsigned)'H', 8); 2966 2967 WriteBlockInfoBlock(); 2968 2969 Context = &SemaRef.Context; 2970 PP = &SemaRef.PP; 2971 WriteASTCore(SemaRef, StatCalls, isysroot, OutputFile, WritingModule); 2972 Context = 0; 2973 PP = 0; 2974 2975 WritingAST = false; 2976} 2977 2978template<typename Vector> 2979static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, 2980 ASTWriter::RecordData &Record) { 2981 for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end(); 2982 I != E; ++I) { 2983 Writer.AddDeclRef(*I, Record); 2984 } 2985} 2986 2987void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2988 StringRef isysroot, 2989 const std::string &OutputFile, 2990 Module *WritingModule) { 2991 using namespace llvm; 2992 2993 // Make sure that the AST reader knows to finalize itself. 2994 if (Chain) 2995 Chain->finalizeForWriting(); 2996 2997 ASTContext &Context = SemaRef.Context; 2998 Preprocessor &PP = SemaRef.PP; 2999 3000 // Set up predefined declaration IDs. 3001 DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID; 3002 if (Context.ObjCIdDecl) 3003 DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID; 3004 if (Context.ObjCSelDecl) 3005 DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID; 3006 if (Context.ObjCClassDecl) 3007 DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID; 3008 if (Context.Int128Decl) 3009 DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID; 3010 if (Context.UInt128Decl) 3011 DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID; 3012 if (Context.ObjCInstanceTypeDecl) 3013 DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID; 3014 3015 if (!Chain) { 3016 // Make sure that we emit IdentifierInfos (and any attached 3017 // declarations) for builtins. We don't need to do this when we're 3018 // emitting chained PCH files, because all of the builtins will be 3019 // in the original PCH file. 3020 // FIXME: Modules won't like this at all. 3021 IdentifierTable &Table = PP.getIdentifierTable(); 3022 SmallVector<const char *, 32> BuiltinNames; 3023 Context.BuiltinInfo.GetBuiltinNames(BuiltinNames, 3024 Context.getLangOptions().NoBuiltin); 3025 for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) 3026 getIdentifierRef(&Table.get(BuiltinNames[I])); 3027 } 3028 3029 // If there are any out-of-date identifiers, bring them up to date. 3030 if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) { 3031 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), 3032 IDEnd = PP.getIdentifierTable().end(); 3033 ID != IDEnd; ++ID) 3034 if (ID->second->isOutOfDate()) 3035 ExtSource->updateOutOfDateIdentifier(*ID->second); 3036 } 3037 3038 // Build a record containing all of the tentative definitions in this file, in 3039 // TentativeDefinitions order. Generally, this record will be empty for 3040 // headers. 3041 RecordData TentativeDefinitions; 3042 AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions); 3043 3044 // Build a record containing all of the file scoped decls in this file. 3045 RecordData UnusedFileScopedDecls; 3046 AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls, 3047 UnusedFileScopedDecls); 3048 3049 // Build a record containing all of the delegating constructors we still need 3050 // to resolve. 3051 RecordData DelegatingCtorDecls; 3052 AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls); 3053 3054 // Write the set of weak, undeclared identifiers. We always write the 3055 // entire table, since later PCH files in a PCH chain are only interested in 3056 // the results at the end of the chain. 3057 RecordData WeakUndeclaredIdentifiers; 3058 if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { 3059 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator 3060 I = SemaRef.WeakUndeclaredIdentifiers.begin(), 3061 E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { 3062 AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); 3063 AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); 3064 AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); 3065 WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); 3066 } 3067 } 3068 3069 // Build a record containing all of the locally-scoped external 3070 // declarations in this header file. Generally, this record will be 3071 // empty. 3072 RecordData LocallyScopedExternalDecls; 3073 // FIXME: This is filling in the AST file in densemap order which is 3074 // nondeterminstic! 3075 for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator 3076 TD = SemaRef.LocallyScopedExternalDecls.begin(), 3077 TDEnd = SemaRef.LocallyScopedExternalDecls.end(); 3078 TD != TDEnd; ++TD) { 3079 if (!TD->second->isFromASTFile()) 3080 AddDeclRef(TD->second, LocallyScopedExternalDecls); 3081 } 3082 3083 // Build a record containing all of the ext_vector declarations. 3084 RecordData ExtVectorDecls; 3085 AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls); 3086 3087 // Build a record containing all of the VTable uses information. 3088 RecordData VTableUses; 3089 if (!SemaRef.VTableUses.empty()) { 3090 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 3091 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 3092 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 3093 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 3094 } 3095 } 3096 3097 // Build a record containing all of dynamic classes declarations. 3098 RecordData DynamicClasses; 3099 AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses); 3100 3101 // Build a record containing all of pending implicit instantiations. 3102 RecordData PendingInstantiations; 3103 for (std::deque<Sema::PendingImplicitInstantiation>::iterator 3104 I = SemaRef.PendingInstantiations.begin(), 3105 N = SemaRef.PendingInstantiations.end(); I != N; ++I) { 3106 AddDeclRef(I->first, PendingInstantiations); 3107 AddSourceLocation(I->second, PendingInstantiations); 3108 } 3109 assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 3110 "There are local ones at end of translation unit!"); 3111 3112 // Build a record containing some declaration references. 3113 RecordData SemaDeclRefs; 3114 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { 3115 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 3116 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 3117 } 3118 3119 RecordData CUDASpecialDeclRefs; 3120 if (Context.getcudaConfigureCallDecl()) { 3121 AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); 3122 } 3123 3124 // Build a record containing all of the known namespaces. 3125 RecordData KnownNamespaces; 3126 for (llvm::DenseMap<NamespaceDecl*, bool>::iterator 3127 I = SemaRef.KnownNamespaces.begin(), 3128 IEnd = SemaRef.KnownNamespaces.end(); 3129 I != IEnd; ++I) { 3130 if (!I->second) 3131 AddDeclRef(I->first, KnownNamespaces); 3132 } 3133 3134 // Write the remaining AST contents. 3135 RecordData Record; 3136 Stream.EnterSubblock(AST_BLOCK_ID, 5); 3137 WriteMetadata(Context, isysroot, OutputFile); 3138 WriteLanguageOptions(Context.getLangOptions()); 3139 if (StatCalls && isysroot.empty()) 3140 WriteStatCache(*StatCalls); 3141 3142 // Create a lexical update block containing all of the declarations in the 3143 // translation unit that do not come from other AST files. 3144 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 3145 SmallVector<KindDeclIDPair, 64> NewGlobalDecls; 3146 for (DeclContext::decl_iterator I = TU->noload_decls_begin(), 3147 E = TU->noload_decls_end(); 3148 I != E; ++I) { 3149 if (!(*I)->isFromASTFile()) 3150 NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I))); 3151 } 3152 3153 llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); 3154 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); 3155 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 3156 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); 3157 Record.clear(); 3158 Record.push_back(TU_UPDATE_LEXICAL); 3159 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, 3160 data(NewGlobalDecls)); 3161 3162 // And a visible updates block for the translation unit. 3163 Abv = new llvm::BitCodeAbbrev(); 3164 Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); 3165 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 3166 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32)); 3167 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 3168 UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv); 3169 WriteDeclContextVisibleUpdate(TU); 3170 3171 // If the translation unit has an anonymous namespace, and we don't already 3172 // have an update block for it, write it as an update block. 3173 if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { 3174 ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; 3175 if (Record.empty()) { 3176 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE); 3177 Record.push_back(reinterpret_cast<uint64_t>(NS)); 3178 } 3179 } 3180 3181 // Resolve any declaration pointers within the declaration updates block. 3182 ResolveDeclUpdatesBlocks(); 3183 3184 // Form the record of special types. 3185 RecordData SpecialTypes; 3186 AddTypeRef(Context.getBuiltinVaListType(), SpecialTypes); 3187 AddTypeRef(Context.ObjCProtoType, SpecialTypes); 3188 AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); 3189 AddTypeRef(Context.getFILEType(), SpecialTypes); 3190 AddTypeRef(Context.getjmp_bufType(), SpecialTypes); 3191 AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes); 3192 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes); 3193 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); 3194 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); 3195 AddTypeRef(Context.getucontext_tType(), SpecialTypes); 3196 3197 // If we're emitting a module, write out the submodule information. 3198 if (WritingModule) 3199 WriteSubmodules(WritingModule); 3200 3201 // Keep writing types and declarations until all types and 3202 // declarations have been written. 3203 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); 3204 WriteDeclsBlockAbbrevs(); 3205 for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(), 3206 E = DeclsToRewrite.end(); 3207 I != E; ++I) 3208 DeclTypesToEmit.push(const_cast<Decl*>(*I)); 3209 while (!DeclTypesToEmit.empty()) { 3210 DeclOrType DOT = DeclTypesToEmit.front(); 3211 DeclTypesToEmit.pop(); 3212 if (DOT.isType()) 3213 WriteType(DOT.getType()); 3214 else 3215 WriteDecl(Context, DOT.getDecl()); 3216 } 3217 Stream.ExitBlock(); 3218 3219 WriteFileDeclIDsMap(); 3220 WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); 3221 3222 if (Chain) { 3223 // Write the mapping information describing our module dependencies and how 3224 // each of those modules were mapped into our own offset/ID space, so that 3225 // the reader can build the appropriate mapping to its own offset/ID space. 3226 // The map consists solely of a blob with the following format: 3227 // *(module-name-len:i16 module-name:len*i8 3228 // source-location-offset:i32 3229 // identifier-id:i32 3230 // preprocessed-entity-id:i32 3231 // macro-definition-id:i32 3232 // submodule-id:i32 3233 // selector-id:i32 3234 // declaration-id:i32 3235 // c++-base-specifiers-id:i32 3236 // type-id:i32) 3237 // 3238 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 3239 Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); 3240 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3241 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); 3242 llvm::SmallString<2048> Buffer; 3243 { 3244 llvm::raw_svector_ostream Out(Buffer); 3245 for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), 3246 MEnd = Chain->ModuleMgr.end(); 3247 M != MEnd; ++M) { 3248 StringRef FileName = (*M)->FileName; 3249 io::Emit16(Out, FileName.size()); 3250 Out.write(FileName.data(), FileName.size()); 3251 io::Emit32(Out, (*M)->SLocEntryBaseOffset); 3252 io::Emit32(Out, (*M)->BaseIdentifierID); 3253 io::Emit32(Out, (*M)->BasePreprocessedEntityID); 3254 io::Emit32(Out, (*M)->BaseSubmoduleID); 3255 io::Emit32(Out, (*M)->BaseSelectorID); 3256 io::Emit32(Out, (*M)->BaseDeclID); 3257 io::Emit32(Out, (*M)->BaseTypeIndex); 3258 } 3259 } 3260 Record.clear(); 3261 Record.push_back(MODULE_OFFSET_MAP); 3262 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, 3263 Buffer.data(), Buffer.size()); 3264 } 3265 WritePreprocessor(PP, WritingModule != 0); 3266 WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot); 3267 WriteSelectors(SemaRef); 3268 WriteReferencedSelectorsPool(SemaRef); 3269 WriteIdentifierTable(PP, SemaRef.IdResolver, WritingModule != 0); 3270 WriteFPPragmaOptions(SemaRef.getFPOptions()); 3271 WriteOpenCLExtensions(SemaRef); 3272 3273 WriteTypeDeclOffsets(); 3274 WritePragmaDiagnosticMappings(Context.getDiagnostics()); 3275 3276 WriteCXXBaseSpecifiersOffsets(); 3277 3278 Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); 3279 3280 /// Build a record containing first declarations from a chained PCH and the 3281 /// most recent declarations in this AST that they point to. 3282 RecordData FirstLatestDeclIDs; 3283 for (FirstLatestDeclMap::iterator I = FirstLatestDecls.begin(), 3284 E = FirstLatestDecls.end(); 3285 I != E; ++I) { 3286 AddDeclRef(I->first, FirstLatestDeclIDs); 3287 AddDeclRef(I->second, FirstLatestDeclIDs); 3288 } 3289 3290 if (!FirstLatestDeclIDs.empty()) 3291 Stream.EmitRecord(REDECLS_UPDATE_LATEST, FirstLatestDeclIDs); 3292 3293 // Write the record containing external, unnamed definitions. 3294 if (!ExternalDefinitions.empty()) 3295 Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions); 3296 3297 // Write the record containing tentative definitions. 3298 if (!TentativeDefinitions.empty()) 3299 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 3300 3301 // Write the record containing unused file scoped decls. 3302 if (!UnusedFileScopedDecls.empty()) 3303 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 3304 3305 // Write the record containing weak undeclared identifiers. 3306 if (!WeakUndeclaredIdentifiers.empty()) 3307 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 3308 WeakUndeclaredIdentifiers); 3309 3310 // Write the record containing locally-scoped external definitions. 3311 if (!LocallyScopedExternalDecls.empty()) 3312 Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS, 3313 LocallyScopedExternalDecls); 3314 3315 // Write the record containing ext_vector type names. 3316 if (!ExtVectorDecls.empty()) 3317 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 3318 3319 // Write the record containing VTable uses information. 3320 if (!VTableUses.empty()) 3321 Stream.EmitRecord(VTABLE_USES, VTableUses); 3322 3323 // Write the record containing dynamic classes declarations. 3324 if (!DynamicClasses.empty()) 3325 Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); 3326 3327 // Write the record containing pending implicit instantiations. 3328 if (!PendingInstantiations.empty()) 3329 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); 3330 3331 // Write the record containing declaration references of Sema. 3332 if (!SemaDeclRefs.empty()) 3333 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 3334 3335 // Write the record containing CUDA-specific declaration references. 3336 if (!CUDASpecialDeclRefs.empty()) 3337 Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); 3338 3339 // Write the delegating constructors. 3340 if (!DelegatingCtorDecls.empty()) 3341 Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls); 3342 3343 // Write the known namespaces. 3344 if (!KnownNamespaces.empty()) 3345 Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces); 3346 3347 // Write the visible updates to DeclContexts. 3348 for (llvm::SmallPtrSet<const DeclContext *, 16>::iterator 3349 I = UpdatedDeclContexts.begin(), 3350 E = UpdatedDeclContexts.end(); 3351 I != E; ++I) 3352 WriteDeclContextVisibleUpdate(*I); 3353 3354 if (!WritingModule) { 3355 // Write the submodules that were imported, if any. 3356 RecordData ImportedModules; 3357 for (ASTContext::import_iterator I = Context.local_import_begin(), 3358 IEnd = Context.local_import_end(); 3359 I != IEnd; ++I) { 3360 assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); 3361 ImportedModules.push_back(SubmoduleIDs[I->getImportedModule()]); 3362 } 3363 if (!ImportedModules.empty()) { 3364 // Sort module IDs. 3365 llvm::array_pod_sort(ImportedModules.begin(), ImportedModules.end()); 3366 3367 // Unique module IDs. 3368 ImportedModules.erase(std::unique(ImportedModules.begin(), 3369 ImportedModules.end()), 3370 ImportedModules.end()); 3371 3372 Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); 3373 } 3374 } 3375 3376 WriteDeclUpdatesBlocks(); 3377 WriteDeclReplacementsBlock(); 3378 WriteChainedObjCCategories(); 3379 3380 // Some simple statistics 3381 Record.clear(); 3382 Record.push_back(NumStatements); 3383 Record.push_back(NumMacros); 3384 Record.push_back(NumLexicalDeclContexts); 3385 Record.push_back(NumVisibleDeclContexts); 3386 Stream.EmitRecord(STATISTICS, Record); 3387 Stream.ExitBlock(); 3388} 3389 3390/// \brief Go through the declaration update blocks and resolve declaration 3391/// pointers into declaration IDs. 3392void ASTWriter::ResolveDeclUpdatesBlocks() { 3393 for (DeclUpdateMap::iterator 3394 I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { 3395 const Decl *D = I->first; 3396 UpdateRecord &URec = I->second; 3397 3398 if (isRewritten(D)) 3399 continue; // The decl will be written completely 3400 3401 unsigned Idx = 0, N = URec.size(); 3402 while (Idx < N) { 3403 switch ((DeclUpdateKind)URec[Idx++]) { 3404 case UPD_CXX_SET_DEFINITIONDATA: 3405 case UPD_CXX_ADDED_IMPLICIT_MEMBER: 3406 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: 3407 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: 3408 URec[Idx] = GetDeclRef(reinterpret_cast<Decl *>(URec[Idx])); 3409 ++Idx; 3410 break; 3411 3412 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: 3413 ++Idx; 3414 break; 3415 } 3416 } 3417 } 3418} 3419 3420void ASTWriter::WriteDeclUpdatesBlocks() { 3421 if (DeclUpdates.empty()) 3422 return; 3423 3424 RecordData OffsetsRecord; 3425 Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); 3426 for (DeclUpdateMap::iterator 3427 I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { 3428 const Decl *D = I->first; 3429 UpdateRecord &URec = I->second; 3430 3431 if (isRewritten(D)) 3432 continue; // The decl will be written completely,no need to store updates. 3433 3434 uint64_t Offset = Stream.GetCurrentBitNo(); 3435 Stream.EmitRecord(DECL_UPDATES, URec); 3436 3437 OffsetsRecord.push_back(GetDeclRef(D)); 3438 OffsetsRecord.push_back(Offset); 3439 } 3440 Stream.ExitBlock(); 3441 Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord); 3442} 3443 3444void ASTWriter::WriteDeclReplacementsBlock() { 3445 if (ReplacedDecls.empty()) 3446 return; 3447 3448 RecordData Record; 3449 for (SmallVector<ReplacedDeclInfo, 16>::iterator 3450 I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { 3451 Record.push_back(I->ID); 3452 Record.push_back(I->Offset); 3453 Record.push_back(I->Loc); 3454 } 3455 Stream.EmitRecord(DECL_REPLACEMENTS, Record); 3456} 3457 3458void ASTWriter::WriteChainedObjCCategories() { 3459 if (LocalChainedObjCCategories.empty()) 3460 return; 3461 3462 RecordData Record; 3463 for (SmallVector<ChainedObjCCategoriesData, 16>::iterator 3464 I = LocalChainedObjCCategories.begin(), 3465 E = LocalChainedObjCCategories.end(); I != E; ++I) { 3466 ChainedObjCCategoriesData &Data = *I; 3467 if (isRewritten(Data.Interface)) 3468 continue; 3469 3470 assert(Data.Interface->getCategoryList()); 3471 serialization::DeclID 3472 HeadCatID = getDeclID(Data.Interface->getCategoryList()); 3473 3474 Record.push_back(getDeclID(Data.Interface)); 3475 Record.push_back(HeadCatID); 3476 Record.push_back(getDeclID(Data.TailCategory)); 3477 } 3478 Stream.EmitRecord(OBJC_CHAINED_CATEGORIES, Record); 3479} 3480 3481void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { 3482 Record.push_back(Loc.getRawEncoding()); 3483} 3484 3485void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { 3486 AddSourceLocation(Range.getBegin(), Record); 3487 AddSourceLocation(Range.getEnd(), Record); 3488} 3489 3490void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) { 3491 Record.push_back(Value.getBitWidth()); 3492 const uint64_t *Words = Value.getRawData(); 3493 Record.append(Words, Words + Value.getNumWords()); 3494} 3495 3496void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) { 3497 Record.push_back(Value.isUnsigned()); 3498 AddAPInt(Value, Record); 3499} 3500 3501void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) { 3502 AddAPInt(Value.bitcastToAPInt(), Record); 3503} 3504 3505void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { 3506 Record.push_back(getIdentifierRef(II)); 3507} 3508 3509IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { 3510 if (II == 0) 3511 return 0; 3512 3513 IdentID &ID = IdentifierIDs[II]; 3514 if (ID == 0) 3515 ID = NextIdentID++; 3516 return ID; 3517} 3518 3519void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) { 3520 Record.push_back(getSelectorRef(SelRef)); 3521} 3522 3523SelectorID ASTWriter::getSelectorRef(Selector Sel) { 3524 if (Sel.getAsOpaquePtr() == 0) { 3525 return 0; 3526 } 3527 3528 SelectorID &SID = SelectorIDs[Sel]; 3529 if (SID == 0 && Chain) { 3530 // This might trigger a ReadSelector callback, which will set the ID for 3531 // this selector. 3532 Chain->LoadSelector(Sel); 3533 } 3534 if (SID == 0) { 3535 SID = NextSelectorID++; 3536 } 3537 return SID; 3538} 3539 3540void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) { 3541 AddDeclRef(Temp->getDestructor(), Record); 3542} 3543 3544void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases, 3545 CXXBaseSpecifier const *BasesEnd, 3546 RecordDataImpl &Record) { 3547 assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded"); 3548 CXXBaseSpecifiersToWrite.push_back( 3549 QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID, 3550 Bases, BasesEnd)); 3551 Record.push_back(NextCXXBaseSpecifiersID++); 3552} 3553 3554void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, 3555 const TemplateArgumentLocInfo &Arg, 3556 RecordDataImpl &Record) { 3557 switch (Kind) { 3558 case TemplateArgument::Expression: 3559 AddStmt(Arg.getAsExpr()); 3560 break; 3561 case TemplateArgument::Type: 3562 AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record); 3563 break; 3564 case TemplateArgument::Template: 3565 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); 3566 AddSourceLocation(Arg.getTemplateNameLoc(), Record); 3567 break; 3568 case TemplateArgument::TemplateExpansion: 3569 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); 3570 AddSourceLocation(Arg.getTemplateNameLoc(), Record); 3571 AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record); 3572 break; 3573 case TemplateArgument::Null: 3574 case TemplateArgument::Integral: 3575 case TemplateArgument::Declaration: 3576 case TemplateArgument::Pack: 3577 break; 3578 } 3579} 3580 3581void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, 3582 RecordDataImpl &Record) { 3583 AddTemplateArgument(Arg.getArgument(), Record); 3584 3585 if (Arg.getArgument().getKind() == TemplateArgument::Expression) { 3586 bool InfoHasSameExpr 3587 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); 3588 Record.push_back(InfoHasSameExpr); 3589 if (InfoHasSameExpr) 3590 return; // Avoid storing the same expr twice. 3591 } 3592 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(), 3593 Record); 3594} 3595 3596void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, 3597 RecordDataImpl &Record) { 3598 if (TInfo == 0) { 3599 AddTypeRef(QualType(), Record); 3600 return; 3601 } 3602 3603 AddTypeLoc(TInfo->getTypeLoc(), Record); 3604} 3605 3606void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) { 3607 AddTypeRef(TL.getType(), Record); 3608 3609 TypeLocWriter TLW(*this, Record); 3610 for (; !TL.isNull(); TL = TL.getNextTypeLoc()) 3611 TLW.Visit(TL); 3612} 3613 3614void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { 3615 Record.push_back(GetOrCreateTypeID(T)); 3616} 3617 3618TypeID ASTWriter::GetOrCreateTypeID( QualType T) { 3619 return MakeTypeID(*Context, T, 3620 std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this)); 3621} 3622 3623TypeID ASTWriter::getTypeID(QualType T) const { 3624 return MakeTypeID(*Context, T, 3625 std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this)); 3626} 3627 3628TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) { 3629 if (T.isNull()) 3630 return TypeIdx(); 3631 assert(!T.getLocalFastQualifiers()); 3632 3633 TypeIdx &Idx = TypeIdxs[T]; 3634 if (Idx.getIndex() == 0) { 3635 // We haven't seen this type before. Assign it a new ID and put it 3636 // into the queue of types to emit. 3637 Idx = TypeIdx(NextTypeID++); 3638 DeclTypesToEmit.push(T); 3639 } 3640 return Idx; 3641} 3642 3643TypeIdx ASTWriter::getTypeIdx(QualType T) const { 3644 if (T.isNull()) 3645 return TypeIdx(); 3646 assert(!T.getLocalFastQualifiers()); 3647 3648 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3649 assert(I != TypeIdxs.end() && "Type not emitted!"); 3650 return I->second; 3651} 3652 3653void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { 3654 Record.push_back(GetDeclRef(D)); 3655} 3656 3657DeclID ASTWriter::GetDeclRef(const Decl *D) { 3658 assert(WritingAST && "Cannot request a declaration ID before AST writing"); 3659 3660 if (D == 0) { 3661 return 0; 3662 } 3663 assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer"); 3664 DeclID &ID = DeclIDs[D]; 3665 if (ID == 0) { 3666 // We haven't seen this declaration before. Give it a new ID and 3667 // enqueue it in the list of declarations to emit. 3668 ID = NextDeclID++; 3669 DeclTypesToEmit.push(const_cast<Decl *>(D)); 3670 } 3671 3672 return ID; 3673} 3674 3675DeclID ASTWriter::getDeclID(const Decl *D) { 3676 if (D == 0) 3677 return 0; 3678 3679 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); 3680 return DeclIDs[D]; 3681} 3682 3683static inline bool compLocDecl(std::pair<unsigned, serialization::DeclID> L, 3684 std::pair<unsigned, serialization::DeclID> R) { 3685 return L.first < R.first; 3686} 3687 3688void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { 3689 assert(ID); 3690 assert(D); 3691 3692 SourceLocation Loc = D->getLocation(); 3693 if (Loc.isInvalid()) 3694 return; 3695 3696 // We only keep track of the file-level declarations of each file. 3697 if (!D->getLexicalDeclContext()->isFileContext()) 3698 return; 3699 3700 SourceManager &SM = Context->getSourceManager(); 3701 SourceLocation FileLoc = SM.getFileLoc(Loc); 3702 assert(SM.isLocalSourceLocation(FileLoc)); 3703 FileID FID; 3704 unsigned Offset; 3705 llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); 3706 if (FID.isInvalid()) 3707 return; 3708 const SrcMgr::SLocEntry *Entry = &SM.getSLocEntry(FID); 3709 assert(Entry->isFile()); 3710 3711 DeclIDInFileInfo *&Info = FileDeclIDs[Entry]; 3712 if (!Info) 3713 Info = new DeclIDInFileInfo(); 3714 3715 std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID); 3716 LocDeclIDsTy &Decls = Info->DeclIDs; 3717 3718 if (Decls.empty() || Decls.back().first <= Offset) { 3719 Decls.push_back(LocDecl); 3720 return; 3721 } 3722 3723 LocDeclIDsTy::iterator 3724 I = std::upper_bound(Decls.begin(), Decls.end(), LocDecl, compLocDecl); 3725 3726 Decls.insert(I, LocDecl); 3727} 3728 3729void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) { 3730 // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. 3731 Record.push_back(Name.getNameKind()); 3732 switch (Name.getNameKind()) { 3733 case DeclarationName::Identifier: 3734 AddIdentifierRef(Name.getAsIdentifierInfo(), Record); 3735 break; 3736 3737 case DeclarationName::ObjCZeroArgSelector: 3738 case DeclarationName::ObjCOneArgSelector: 3739 case DeclarationName::ObjCMultiArgSelector: 3740 AddSelectorRef(Name.getObjCSelector(), Record); 3741 break; 3742 3743 case DeclarationName::CXXConstructorName: 3744 case DeclarationName::CXXDestructorName: 3745 case DeclarationName::CXXConversionFunctionName: 3746 AddTypeRef(Name.getCXXNameType(), Record); 3747 break; 3748 3749 case DeclarationName::CXXOperatorName: 3750 Record.push_back(Name.getCXXOverloadedOperator()); 3751 break; 3752 3753 case DeclarationName::CXXLiteralOperatorName: 3754 AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record); 3755 break; 3756 3757 case DeclarationName::CXXUsingDirective: 3758 // No extra data to emit 3759 break; 3760 } 3761} 3762 3763void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, 3764 DeclarationName Name, RecordDataImpl &Record) { 3765 switch (Name.getNameKind()) { 3766 case DeclarationName::CXXConstructorName: 3767 case DeclarationName::CXXDestructorName: 3768 case DeclarationName::CXXConversionFunctionName: 3769 AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record); 3770 break; 3771 3772 case DeclarationName::CXXOperatorName: 3773 AddSourceLocation( 3774 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc), 3775 Record); 3776 AddSourceLocation( 3777 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc), 3778 Record); 3779 break; 3780 3781 case DeclarationName::CXXLiteralOperatorName: 3782 AddSourceLocation( 3783 SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc), 3784 Record); 3785 break; 3786 3787 case DeclarationName::Identifier: 3788 case DeclarationName::ObjCZeroArgSelector: 3789 case DeclarationName::ObjCOneArgSelector: 3790 case DeclarationName::ObjCMultiArgSelector: 3791 case DeclarationName::CXXUsingDirective: 3792 break; 3793 } 3794} 3795 3796void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 3797 RecordDataImpl &Record) { 3798 AddDeclarationName(NameInfo.getName(), Record); 3799 AddSourceLocation(NameInfo.getLoc(), Record); 3800 AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record); 3801} 3802 3803void ASTWriter::AddQualifierInfo(const QualifierInfo &Info, 3804 RecordDataImpl &Record) { 3805 AddNestedNameSpecifierLoc(Info.QualifierLoc, Record); 3806 Record.push_back(Info.NumTemplParamLists); 3807 for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i) 3808 AddTemplateParameterList(Info.TemplParamLists[i], Record); 3809} 3810 3811void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS, 3812 RecordDataImpl &Record) { 3813 // Nested name specifiers usually aren't too long. I think that 8 would 3814 // typically accommodate the vast majority. 3815 SmallVector<NestedNameSpecifier *, 8> NestedNames; 3816 3817 // Push each of the NNS's onto a stack for serialization in reverse order. 3818 while (NNS) { 3819 NestedNames.push_back(NNS); 3820 NNS = NNS->getPrefix(); 3821 } 3822 3823 Record.push_back(NestedNames.size()); 3824 while(!NestedNames.empty()) { 3825 NNS = NestedNames.pop_back_val(); 3826 NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); 3827 Record.push_back(Kind); 3828 switch (Kind) { 3829 case NestedNameSpecifier::Identifier: 3830 AddIdentifierRef(NNS->getAsIdentifier(), Record); 3831 break; 3832 3833 case NestedNameSpecifier::Namespace: 3834 AddDeclRef(NNS->getAsNamespace(), Record); 3835 break; 3836 3837 case NestedNameSpecifier::NamespaceAlias: 3838 AddDeclRef(NNS->getAsNamespaceAlias(), Record); 3839 break; 3840 3841 case NestedNameSpecifier::TypeSpec: 3842 case NestedNameSpecifier::TypeSpecWithTemplate: 3843 AddTypeRef(QualType(NNS->getAsType(), 0), Record); 3844 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 3845 break; 3846 3847 case NestedNameSpecifier::Global: 3848 // Don't need to write an associated value. 3849 break; 3850 } 3851 } 3852} 3853 3854void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 3855 RecordDataImpl &Record) { 3856 // Nested name specifiers usually aren't too long. I think that 8 would 3857 // typically accommodate the vast majority. 3858 SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 3859 3860 // Push each of the nested-name-specifiers's onto a stack for 3861 // serialization in reverse order. 3862 while (NNS) { 3863 NestedNames.push_back(NNS); 3864 NNS = NNS.getPrefix(); 3865 } 3866 3867 Record.push_back(NestedNames.size()); 3868 while(!NestedNames.empty()) { 3869 NNS = NestedNames.pop_back_val(); 3870 NestedNameSpecifier::SpecifierKind Kind 3871 = NNS.getNestedNameSpecifier()->getKind(); 3872 Record.push_back(Kind); 3873 switch (Kind) { 3874 case NestedNameSpecifier::Identifier: 3875 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record); 3876 AddSourceRange(NNS.getLocalSourceRange(), Record); 3877 break; 3878 3879 case NestedNameSpecifier::Namespace: 3880 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record); 3881 AddSourceRange(NNS.getLocalSourceRange(), Record); 3882 break; 3883 3884 case NestedNameSpecifier::NamespaceAlias: 3885 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record); 3886 AddSourceRange(NNS.getLocalSourceRange(), Record); 3887 break; 3888 3889 case NestedNameSpecifier::TypeSpec: 3890 case NestedNameSpecifier::TypeSpecWithTemplate: 3891 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 3892 AddTypeLoc(NNS.getTypeLoc(), Record); 3893 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); 3894 break; 3895 3896 case NestedNameSpecifier::Global: 3897 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); 3898 break; 3899 } 3900 } 3901} 3902 3903void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) { 3904 TemplateName::NameKind Kind = Name.getKind(); 3905 Record.push_back(Kind); 3906 switch (Kind) { 3907 case TemplateName::Template: 3908 AddDeclRef(Name.getAsTemplateDecl(), Record); 3909 break; 3910 3911 case TemplateName::OverloadedTemplate: { 3912 OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); 3913 Record.push_back(OvT->size()); 3914 for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end(); 3915 I != E; ++I) 3916 AddDeclRef(*I, Record); 3917 break; 3918 } 3919 3920 case TemplateName::QualifiedTemplate: { 3921 QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); 3922 AddNestedNameSpecifier(QualT->getQualifier(), Record); 3923 Record.push_back(QualT->hasTemplateKeyword()); 3924 AddDeclRef(QualT->getTemplateDecl(), Record); 3925 break; 3926 } 3927 3928 case TemplateName::DependentTemplate: { 3929 DependentTemplateName *DepT = Name.getAsDependentTemplateName(); 3930 AddNestedNameSpecifier(DepT->getQualifier(), Record); 3931 Record.push_back(DepT->isIdentifier()); 3932 if (DepT->isIdentifier()) 3933 AddIdentifierRef(DepT->getIdentifier(), Record); 3934 else 3935 Record.push_back(DepT->getOperator()); 3936 break; 3937 } 3938 3939 case TemplateName::SubstTemplateTemplateParm: { 3940 SubstTemplateTemplateParmStorage *subst 3941 = Name.getAsSubstTemplateTemplateParm(); 3942 AddDeclRef(subst->getParameter(), Record); 3943 AddTemplateName(subst->getReplacement(), Record); 3944 break; 3945 } 3946 3947 case TemplateName::SubstTemplateTemplateParmPack: { 3948 SubstTemplateTemplateParmPackStorage *SubstPack 3949 = Name.getAsSubstTemplateTemplateParmPack(); 3950 AddDeclRef(SubstPack->getParameterPack(), Record); 3951 AddTemplateArgument(SubstPack->getArgumentPack(), Record); 3952 break; 3953 } 3954 } 3955} 3956 3957void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, 3958 RecordDataImpl &Record) { 3959 Record.push_back(Arg.getKind()); 3960 switch (Arg.getKind()) { 3961 case TemplateArgument::Null: 3962 break; 3963 case TemplateArgument::Type: 3964 AddTypeRef(Arg.getAsType(), Record); 3965 break; 3966 case TemplateArgument::Declaration: 3967 AddDeclRef(Arg.getAsDecl(), Record); 3968 break; 3969 case TemplateArgument::Integral: 3970 AddAPSInt(*Arg.getAsIntegral(), Record); 3971 AddTypeRef(Arg.getIntegralType(), Record); 3972 break; 3973 case TemplateArgument::Template: 3974 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); 3975 break; 3976 case TemplateArgument::TemplateExpansion: 3977 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); 3978 if (llvm::Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions()) 3979 Record.push_back(*NumExpansions + 1); 3980 else 3981 Record.push_back(0); 3982 break; 3983 case TemplateArgument::Expression: 3984 AddStmt(Arg.getAsExpr()); 3985 break; 3986 case TemplateArgument::Pack: 3987 Record.push_back(Arg.pack_size()); 3988 for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); 3989 I != E; ++I) 3990 AddTemplateArgument(*I, Record); 3991 break; 3992 } 3993} 3994 3995void 3996ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams, 3997 RecordDataImpl &Record) { 3998 assert(TemplateParams && "No TemplateParams!"); 3999 AddSourceLocation(TemplateParams->getTemplateLoc(), Record); 4000 AddSourceLocation(TemplateParams->getLAngleLoc(), Record); 4001 AddSourceLocation(TemplateParams->getRAngleLoc(), Record); 4002 Record.push_back(TemplateParams->size()); 4003 for (TemplateParameterList::const_iterator 4004 P = TemplateParams->begin(), PEnd = TemplateParams->end(); 4005 P != PEnd; ++P) 4006 AddDeclRef(*P, Record); 4007} 4008 4009/// \brief Emit a template argument list. 4010void 4011ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs, 4012 RecordDataImpl &Record) { 4013 assert(TemplateArgs && "No TemplateArgs!"); 4014 Record.push_back(TemplateArgs->size()); 4015 for (int i=0, e = TemplateArgs->size(); i != e; ++i) 4016 AddTemplateArgument(TemplateArgs->get(i), Record); 4017} 4018 4019 4020void 4021ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordDataImpl &Record) { 4022 Record.push_back(Set.size()); 4023 for (UnresolvedSetImpl::const_iterator 4024 I = Set.begin(), E = Set.end(); I != E; ++I) { 4025 AddDeclRef(I.getDecl(), Record); 4026 Record.push_back(I.getAccess()); 4027 } 4028} 4029 4030void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, 4031 RecordDataImpl &Record) { 4032 Record.push_back(Base.isVirtual()); 4033 Record.push_back(Base.isBaseOfClass()); 4034 Record.push_back(Base.getAccessSpecifierAsWritten()); 4035 Record.push_back(Base.getInheritConstructors()); 4036 AddTypeSourceInfo(Base.getTypeSourceInfo(), Record); 4037 AddSourceRange(Base.getSourceRange(), Record); 4038 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() 4039 : SourceLocation(), 4040 Record); 4041} 4042 4043void ASTWriter::FlushCXXBaseSpecifiers() { 4044 RecordData Record; 4045 for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) { 4046 Record.clear(); 4047 4048 // Record the offset of this base-specifier set. 4049 unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1; 4050 if (Index == CXXBaseSpecifiersOffsets.size()) 4051 CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo()); 4052 else { 4053 if (Index > CXXBaseSpecifiersOffsets.size()) 4054 CXXBaseSpecifiersOffsets.resize(Index + 1); 4055 CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo(); 4056 } 4057 4058 const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases, 4059 *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd; 4060 Record.push_back(BEnd - B); 4061 for (; B != BEnd; ++B) 4062 AddCXXBaseSpecifier(*B, Record); 4063 Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record); 4064 4065 // Flush any expressions that were written as part of the base specifiers. 4066 FlushStmts(); 4067 } 4068 4069 CXXBaseSpecifiersToWrite.clear(); 4070} 4071 4072void ASTWriter::AddCXXCtorInitializers( 4073 const CXXCtorInitializer * const *CtorInitializers, 4074 unsigned NumCtorInitializers, 4075 RecordDataImpl &Record) { 4076 Record.push_back(NumCtorInitializers); 4077 for (unsigned i=0; i != NumCtorInitializers; ++i) { 4078 const CXXCtorInitializer *Init = CtorInitializers[i]; 4079 4080 if (Init->isBaseInitializer()) { 4081 Record.push_back(CTOR_INITIALIZER_BASE); 4082 AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); 4083 Record.push_back(Init->isBaseVirtual()); 4084 } else if (Init->isDelegatingInitializer()) { 4085 Record.push_back(CTOR_INITIALIZER_DELEGATING); 4086 AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); 4087 } else if (Init->isMemberInitializer()){ 4088 Record.push_back(CTOR_INITIALIZER_MEMBER); 4089 AddDeclRef(Init->getMember(), Record); 4090 } else { 4091 Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); 4092 AddDeclRef(Init->getIndirectMember(), Record); 4093 } 4094 4095 AddSourceLocation(Init->getMemberLocation(), Record); 4096 AddStmt(Init->getInit()); 4097 AddSourceLocation(Init->getLParenLoc(), Record); 4098 AddSourceLocation(Init->getRParenLoc(), Record); 4099 Record.push_back(Init->isWritten()); 4100 if (Init->isWritten()) { 4101 Record.push_back(Init->getSourceOrder()); 4102 } else { 4103 Record.push_back(Init->getNumArrayIndices()); 4104 for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i) 4105 AddDeclRef(Init->getArrayIndex(i), Record); 4106 } 4107 } 4108} 4109 4110void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) { 4111 assert(D->DefinitionData); 4112 struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData; 4113 Record.push_back(Data.UserDeclaredConstructor); 4114 Record.push_back(Data.UserDeclaredCopyConstructor); 4115 Record.push_back(Data.UserDeclaredMoveConstructor); 4116 Record.push_back(Data.UserDeclaredCopyAssignment); 4117 Record.push_back(Data.UserDeclaredMoveAssignment); 4118 Record.push_back(Data.UserDeclaredDestructor); 4119 Record.push_back(Data.Aggregate); 4120 Record.push_back(Data.PlainOldData); 4121 Record.push_back(Data.Empty); 4122 Record.push_back(Data.Polymorphic); 4123 Record.push_back(Data.Abstract); 4124 Record.push_back(Data.IsStandardLayout); 4125 Record.push_back(Data.HasNoNonEmptyBases); 4126 Record.push_back(Data.HasPrivateFields); 4127 Record.push_back(Data.HasProtectedFields); 4128 Record.push_back(Data.HasPublicFields); 4129 Record.push_back(Data.HasMutableFields); 4130 Record.push_back(Data.HasTrivialDefaultConstructor); 4131 Record.push_back(Data.HasConstexprNonCopyMoveConstructor); 4132 Record.push_back(Data.HasTrivialCopyConstructor); 4133 Record.push_back(Data.HasTrivialMoveConstructor); 4134 Record.push_back(Data.HasTrivialCopyAssignment); 4135 Record.push_back(Data.HasTrivialMoveAssignment); 4136 Record.push_back(Data.HasTrivialDestructor); 4137 Record.push_back(Data.HasNonLiteralTypeFieldsOrBases); 4138 Record.push_back(Data.ComputedVisibleConversions); 4139 Record.push_back(Data.UserProvidedDefaultConstructor); 4140 Record.push_back(Data.DeclaredDefaultConstructor); 4141 Record.push_back(Data.DeclaredCopyConstructor); 4142 Record.push_back(Data.DeclaredMoveConstructor); 4143 Record.push_back(Data.DeclaredCopyAssignment); 4144 Record.push_back(Data.DeclaredMoveAssignment); 4145 Record.push_back(Data.DeclaredDestructor); 4146 Record.push_back(Data.FailedImplicitMoveConstructor); 4147 Record.push_back(Data.FailedImplicitMoveAssignment); 4148 4149 Record.push_back(Data.NumBases); 4150 if (Data.NumBases > 0) 4151 AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases, 4152 Record); 4153 4154 // FIXME: Make VBases lazily computed when needed to avoid storing them. 4155 Record.push_back(Data.NumVBases); 4156 if (Data.NumVBases > 0) 4157 AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases, 4158 Record); 4159 4160 AddUnresolvedSet(Data.Conversions, Record); 4161 AddUnresolvedSet(Data.VisibleConversions, Record); 4162 // Data.Definition is the owning decl, no need to write it. 4163 AddDeclRef(Data.FirstFriend, Record); 4164} 4165 4166void ASTWriter::ReaderInitialized(ASTReader *Reader) { 4167 assert(Reader && "Cannot remove chain"); 4168 assert((!Chain || Chain == Reader) && "Cannot replace chain"); 4169 assert(FirstDeclID == NextDeclID && 4170 FirstTypeID == NextTypeID && 4171 FirstIdentID == NextIdentID && 4172 FirstSubmoduleID == NextSubmoduleID && 4173 FirstSelectorID == NextSelectorID && 4174 "Setting chain after writing has started."); 4175 4176 Chain = Reader; 4177 4178 FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); 4179 FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); 4180 FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); 4181 FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); 4182 FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); 4183 NextDeclID = FirstDeclID; 4184 NextTypeID = FirstTypeID; 4185 NextIdentID = FirstIdentID; 4186 NextSelectorID = FirstSelectorID; 4187 NextSubmoduleID = FirstSubmoduleID; 4188} 4189 4190void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { 4191 IdentifierIDs[II] = ID; 4192 if (II->hasMacroDefinition()) 4193 DeserializedMacroNames.push_back(II); 4194} 4195 4196void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { 4197 // Always take the highest-numbered type index. This copes with an interesting 4198 // case for chained AST writing where we schedule writing the type and then, 4199 // later, deserialize the type from another AST. In this case, we want to 4200 // keep the higher-numbered entry so that we can properly write it out to 4201 // the AST file. 4202 TypeIdx &StoredIdx = TypeIdxs[T]; 4203 if (Idx.getIndex() >= StoredIdx.getIndex()) 4204 StoredIdx = Idx; 4205} 4206 4207void ASTWriter::DeclRead(DeclID ID, const Decl *D) { 4208 DeclIDs[D] = ID; 4209} 4210 4211void ASTWriter::SelectorRead(SelectorID ID, Selector S) { 4212 SelectorIDs[S] = ID; 4213} 4214 4215void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, 4216 MacroDefinition *MD) { 4217 assert(MacroDefinitions.find(MD) == MacroDefinitions.end()); 4218 MacroDefinitions[MD] = ID; 4219} 4220 4221void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { 4222 assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); 4223 SubmoduleIDs[Mod] = ID; 4224} 4225 4226void ASTWriter::CompletedTagDefinition(const TagDecl *D) { 4227 assert(D->isCompleteDefinition()); 4228 assert(!WritingAST && "Already writing the AST!"); 4229 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 4230 // We are interested when a PCH decl is modified. 4231 if (RD->isFromASTFile()) { 4232 // A forward reference was mutated into a definition. Rewrite it. 4233 // FIXME: This happens during template instantiation, should we 4234 // have created a new definition decl instead ? 4235 RewriteDecl(RD); 4236 } 4237 4238 for (CXXRecordDecl::redecl_iterator 4239 I = RD->redecls_begin(), E = RD->redecls_end(); I != E; ++I) { 4240 CXXRecordDecl *Redecl = cast<CXXRecordDecl>(*I); 4241 if (Redecl == RD) 4242 continue; 4243 4244 // We are interested when a PCH decl is modified. 4245 if (Redecl->isFromASTFile()) { 4246 UpdateRecord &Record = DeclUpdates[Redecl]; 4247 Record.push_back(UPD_CXX_SET_DEFINITIONDATA); 4248 assert(Redecl->DefinitionData); 4249 assert(Redecl->DefinitionData->Definition == D); 4250 Record.push_back(reinterpret_cast<uint64_t>(D)); // the DefinitionDecl 4251 } 4252 } 4253 } 4254} 4255void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { 4256 assert(!WritingAST && "Already writing the AST!"); 4257 4258 // TU and namespaces are handled elsewhere. 4259 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC)) 4260 return; 4261 4262 if (!(!D->isFromASTFile() && cast<Decl>(DC)->isFromASTFile())) 4263 return; // Not a source decl added to a DeclContext from PCH. 4264 4265 AddUpdatedDeclContext(DC); 4266} 4267 4268void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { 4269 assert(!WritingAST && "Already writing the AST!"); 4270 assert(D->isImplicit()); 4271 if (!(!D->isFromASTFile() && RD->isFromASTFile())) 4272 return; // Not a source member added to a class from PCH. 4273 if (!isa<CXXMethodDecl>(D)) 4274 return; // We are interested in lazily declared implicit methods. 4275 4276 // A decl coming from PCH was modified. 4277 assert(RD->isCompleteDefinition()); 4278 UpdateRecord &Record = DeclUpdates[RD]; 4279 Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER); 4280 Record.push_back(reinterpret_cast<uint64_t>(D)); 4281} 4282 4283void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, 4284 const ClassTemplateSpecializationDecl *D) { 4285 // The specializations set is kept in the canonical template. 4286 assert(!WritingAST && "Already writing the AST!"); 4287 TD = TD->getCanonicalDecl(); 4288 if (!(!D->isFromASTFile() && TD->isFromASTFile())) 4289 return; // Not a source specialization added to a template from PCH. 4290 4291 UpdateRecord &Record = DeclUpdates[TD]; 4292 Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); 4293 Record.push_back(reinterpret_cast<uint64_t>(D)); 4294} 4295 4296void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, 4297 const FunctionDecl *D) { 4298 // The specializations set is kept in the canonical template. 4299 assert(!WritingAST && "Already writing the AST!"); 4300 TD = TD->getCanonicalDecl(); 4301 if (!(!D->isFromASTFile() && TD->isFromASTFile())) 4302 return; // Not a source specialization added to a template from PCH. 4303 4304 UpdateRecord &Record = DeclUpdates[TD]; 4305 Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); 4306 Record.push_back(reinterpret_cast<uint64_t>(D)); 4307} 4308 4309void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { 4310 assert(!WritingAST && "Already writing the AST!"); 4311 if (!D->isFromASTFile()) 4312 return; // Declaration not imported from PCH. 4313 4314 // Implicit decl from a PCH was defined. 4315 // FIXME: Should implicit definition be a separate FunctionDecl? 4316 RewriteDecl(D); 4317} 4318 4319void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) { 4320 assert(!WritingAST && "Already writing the AST!"); 4321 if (!D->isFromASTFile()) 4322 return; 4323 4324 // Since the actual instantiation is delayed, this really means that we need 4325 // to update the instantiation location. 4326 UpdateRecord &Record = DeclUpdates[D]; 4327 Record.push_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER); 4328 AddSourceLocation( 4329 D->getMemberSpecializationInfo()->getPointOfInstantiation(), Record); 4330} 4331 4332void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, 4333 const ObjCInterfaceDecl *IFD) { 4334 assert(!WritingAST && "Already writing the AST!"); 4335 if (!IFD->isFromASTFile()) 4336 return; // Declaration not imported from PCH. 4337 if (CatD->getNextClassCategory() && 4338 !CatD->getNextClassCategory()->isFromASTFile()) 4339 return; // We already recorded that the tail of a category chain should be 4340 // attached to an interface. 4341 4342 ChainedObjCCategoriesData Data = { IFD, CatD }; 4343 LocalChainedObjCCategories.push_back(Data); 4344} 4345 4346void ASTWriter::CompletedObjCForwardRef(const ObjCContainerDecl *D) { 4347 assert(!WritingAST && "Already writing the AST!"); 4348 if (!D->isFromASTFile()) 4349 return; // Declaration not imported from PCH. 4350 4351 RewriteDecl(D); 4352} 4353 4354void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, 4355 const ObjCPropertyDecl *OrigProp, 4356 const ObjCCategoryDecl *ClassExt) { 4357 const ObjCInterfaceDecl *D = ClassExt->getClassInterface(); 4358 if (!D) 4359 return; 4360 4361 assert(!WritingAST && "Already writing the AST!"); 4362 if (!D->isFromASTFile()) 4363 return; // Declaration not imported from PCH. 4364 4365 RewriteDecl(D); 4366} 4367 4368void ASTWriter::UpdatedAttributeList(const Decl *D) { 4369 assert(!WritingAST && "Already writing the AST!"); 4370 if (!D->isFromASTFile()) 4371 return; // Declaration not imported from PCH. 4372 4373 RewriteDecl(D); 4374} 4375