ASTWriter.cpp revision 8538e8d43a3a9bd439c987c0de37bcbf035dd391
147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org//===--- ASTWriter.cpp - AST File Writer ----------------------------------===// 247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// 347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// The LLVM Compiler Infrastructure 447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// 547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// This file is distributed under the University of Illinois Open Source 647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// License. See LICENSE.TXT for details. 747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// 847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org//===----------------------------------------------------------------------===// 947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// 1047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// This file defines the ASTWriter class, which writes AST files. 1147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// 1247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org//===----------------------------------------------------------------------===// 1347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 1447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Serialization/ASTWriter.h" 1547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Sema/Sema.h" 1647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Sema/IdentifierResolver.h" 1747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/AST/ASTContext.h" 1847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/AST/Decl.h" 1947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/AST/DeclContextInternals.h" 2047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/AST/Expr.h" 2147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/AST/Type.h" 2247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/AST/TypeLocVisitor.h" 2347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Serialization/ASTReader.h" 2447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Lex/MacroInfo.h" 2547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Lex/PreprocessingRecord.h" 2647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Lex/Preprocessor.h" 2747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Lex/HeaderSearch.h" 2847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Basic/FileManager.h" 2947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Basic/OnDiskHashTable.h" 3047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Basic/SourceManager.h" 3147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Basic/SourceManagerInternals.h" 3247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Basic/TargetInfo.h" 3347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/Basic/Version.h" 3447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "llvm/ADT/APFloat.h" 3547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "llvm/ADT/APInt.h" 3647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "llvm/ADT/StringExtras.h" 3747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "llvm/Bitcode/BitstreamWriter.h" 3847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "llvm/Support/MemoryBuffer.h" 3947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "llvm/System/Path.h" 4047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include <cstdio> 4147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgusing namespace clang; 4247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgusing namespace clang::serialization; 4347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 4447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgtemplate <typename T, typename Allocator> 4547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgT *data(std::vector<T, Allocator> &v) { 4647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org return v.empty() ? 0 : &v.front(); 4747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 4847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgtemplate <typename T, typename Allocator> 4947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgconst T *data(const std::vector<T, Allocator> &v) { 5047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org return v.empty() ? 0 : &v.front(); 5147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 5247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 5347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org//===----------------------------------------------------------------------===// 5447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org// Type serialization 5547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org//===----------------------------------------------------------------------===// 5647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 5747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgnamespace { 5847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org class ASTTypeWriter { 5947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org ASTWriter &Writer; 6047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org ASTWriter::RecordData &Record; 6147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 6247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org public: 6347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org /// \brief Type code that corresponds to the record generated. 6447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org TypeCode Code; 6547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 6647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordData &Record) 6747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { } 6847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 6947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org void VisitArrayType(const ArrayType *T); 7047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org void VisitFunctionType(const FunctionType *T); 7147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org void VisitTagType(const TagType *T); 7247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 7347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); 7447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#define ABSTRACT_TYPE(Class, Base) 7547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org#include "clang/AST/TypeNodes.def" 7647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org }; 7747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 7847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 7947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { 8047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org assert(false && "Built-in types are never serialized"); 8147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 8247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 8347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitComplexType(const ComplexType *T) { 8447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(T->getElementType(), Record); 8547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_COMPLEX; 8647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 8747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 8847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitPointerType(const PointerType *T) { 8947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(T->getPointeeType(), Record); 9047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_POINTER; 9147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 9247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 9347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { 9447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(T->getPointeeType(), Record); 9547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_BLOCK_POINTER; 9647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 9747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 9847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { 9947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(T->getPointeeType(), Record); 10047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_LVALUE_REFERENCE; 10147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 10247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 10347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { 10447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(T->getPointeeType(), Record); 10547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_RVALUE_REFERENCE; 10647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 10747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 10847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { 10947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(T->getPointeeType(), Record); 11047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(QualType(T->getClass(), 0), Record); 11147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_MEMBER_POINTER; 11247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 11347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 11447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitArrayType(const ArrayType *T) { 11547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddTypeRef(T->getElementType(), Record); 11647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Record.push_back(T->getSizeModifier()); // FIXME: stable values 11747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values 11847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 11947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 12047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { 12147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org VisitArrayType(T); 12247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddAPInt(T->getSize(), Record); 12347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_CONSTANT_ARRAY; 12447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 12547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 12647be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 12747be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org VisitArrayType(T); 12847be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Code = TYPE_INCOMPLETE_ARRAY; 12947be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org} 13047be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org 13147be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.orgvoid ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { 13247be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org VisitArrayType(T); 13347be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddSourceLocation(T->getLBracketLoc(), Record); 13447be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddSourceLocation(T->getRBracketLoc(), Record); 13547be73b8629244d6bb63a28198f97f040ce53d21henrike@webrtc.org Writer.AddStmt(T->getSizeExpr()); 136 Code = TYPE_VARIABLE_ARRAY; 137} 138 139void ASTTypeWriter::VisitVectorType(const VectorType *T) { 140 Writer.AddTypeRef(T->getElementType(), Record); 141 Record.push_back(T->getNumElements()); 142 Record.push_back(T->getAltiVecSpecific()); 143 Code = TYPE_VECTOR; 144} 145 146void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { 147 VisitVectorType(T); 148 Code = TYPE_EXT_VECTOR; 149} 150 151void ASTTypeWriter::VisitFunctionType(const FunctionType *T) { 152 Writer.AddTypeRef(T->getResultType(), Record); 153 FunctionType::ExtInfo C = T->getExtInfo(); 154 Record.push_back(C.getNoReturn()); 155 Record.push_back(C.getRegParm()); 156 // FIXME: need to stabilize encoding of calling convention... 157 Record.push_back(C.getCC()); 158} 159 160void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 161 VisitFunctionType(T); 162 Code = TYPE_FUNCTION_NO_PROTO; 163} 164 165void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { 166 VisitFunctionType(T); 167 Record.push_back(T->getNumArgs()); 168 for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I) 169 Writer.AddTypeRef(T->getArgType(I), Record); 170 Record.push_back(T->isVariadic()); 171 Record.push_back(T->getTypeQuals()); 172 Record.push_back(T->hasExceptionSpec()); 173 Record.push_back(T->hasAnyExceptionSpec()); 174 Record.push_back(T->getNumExceptions()); 175 for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) 176 Writer.AddTypeRef(T->getExceptionType(I), Record); 177 Code = TYPE_FUNCTION_PROTO; 178} 179 180void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { 181 Writer.AddDeclRef(T->getDecl(), Record); 182 Code = TYPE_UNRESOLVED_USING; 183} 184 185void ASTTypeWriter::VisitTypedefType(const TypedefType *T) { 186 Writer.AddDeclRef(T->getDecl(), Record); 187 assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); 188 Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record); 189 Code = TYPE_TYPEDEF; 190} 191 192void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { 193 Writer.AddStmt(T->getUnderlyingExpr()); 194 Code = TYPE_TYPEOF_EXPR; 195} 196 197void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { 198 Writer.AddTypeRef(T->getUnderlyingType(), Record); 199 Code = TYPE_TYPEOF; 200} 201 202void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { 203 Writer.AddStmt(T->getUnderlyingExpr()); 204 Code = TYPE_DECLTYPE; 205} 206 207void ASTTypeWriter::VisitTagType(const TagType *T) { 208 Record.push_back(T->isDependentType()); 209 Writer.AddDeclRef(T->getDecl(), Record); 210 assert(!T->isBeingDefined() && 211 "Cannot serialize in the middle of a type definition"); 212} 213 214void ASTTypeWriter::VisitRecordType(const RecordType *T) { 215 VisitTagType(T); 216 Code = TYPE_RECORD; 217} 218 219void ASTTypeWriter::VisitEnumType(const EnumType *T) { 220 VisitTagType(T); 221 Code = TYPE_ENUM; 222} 223 224void 225ASTTypeWriter::VisitSubstTemplateTypeParmType( 226 const SubstTemplateTypeParmType *T) { 227 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); 228 Writer.AddTypeRef(T->getReplacementType(), Record); 229 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; 230} 231 232void 233ASTTypeWriter::VisitTemplateSpecializationType( 234 const TemplateSpecializationType *T) { 235 Record.push_back(T->isDependentType()); 236 Writer.AddTemplateName(T->getTemplateName(), Record); 237 Record.push_back(T->getNumArgs()); 238 for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end(); 239 ArgI != ArgE; ++ArgI) 240 Writer.AddTemplateArgument(*ArgI, Record); 241 Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() 242 : T->getCanonicalTypeInternal(), 243 Record); 244 Code = TYPE_TEMPLATE_SPECIALIZATION; 245} 246 247void 248ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { 249 VisitArrayType(T); 250 Writer.AddStmt(T->getSizeExpr()); 251 Writer.AddSourceRange(T->getBracketsRange(), Record); 252 Code = TYPE_DEPENDENT_SIZED_ARRAY; 253} 254 255void 256ASTTypeWriter::VisitDependentSizedExtVectorType( 257 const DependentSizedExtVectorType *T) { 258 // FIXME: Serialize this type (C++ only) 259 assert(false && "Cannot serialize dependent sized extended vector types"); 260} 261 262void 263ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { 264 Record.push_back(T->getDepth()); 265 Record.push_back(T->getIndex()); 266 Record.push_back(T->isParameterPack()); 267 Writer.AddIdentifierRef(T->getName(), Record); 268 Code = TYPE_TEMPLATE_TYPE_PARM; 269} 270 271void 272ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { 273 Record.push_back(T->getKeyword()); 274 Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 275 Writer.AddIdentifierRef(T->getIdentifier(), Record); 276 Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() 277 : T->getCanonicalTypeInternal(), 278 Record); 279 Code = TYPE_DEPENDENT_NAME; 280} 281 282void 283ASTTypeWriter::VisitDependentTemplateSpecializationType( 284 const DependentTemplateSpecializationType *T) { 285 Record.push_back(T->getKeyword()); 286 Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 287 Writer.AddIdentifierRef(T->getIdentifier(), Record); 288 Record.push_back(T->getNumArgs()); 289 for (DependentTemplateSpecializationType::iterator 290 I = T->begin(), E = T->end(); I != E; ++I) 291 Writer.AddTemplateArgument(*I, Record); 292 Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; 293} 294 295void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { 296 Record.push_back(T->getKeyword()); 297 Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 298 Writer.AddTypeRef(T->getNamedType(), Record); 299 Code = TYPE_ELABORATED; 300} 301 302void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { 303 Writer.AddDeclRef(T->getDecl(), Record); 304 Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); 305 Code = TYPE_INJECTED_CLASS_NAME; 306} 307 308void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 309 Writer.AddDeclRef(T->getDecl(), Record); 310 Code = TYPE_OBJC_INTERFACE; 311} 312 313void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { 314 Writer.AddTypeRef(T->getBaseType(), Record); 315 Record.push_back(T->getNumProtocols()); 316 for (ObjCObjectType::qual_iterator I = T->qual_begin(), 317 E = T->qual_end(); I != E; ++I) 318 Writer.AddDeclRef(*I, Record); 319 Code = TYPE_OBJC_OBJECT; 320} 321 322void 323ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 324 Writer.AddTypeRef(T->getPointeeType(), Record); 325 Code = TYPE_OBJC_OBJECT_POINTER; 326} 327 328namespace { 329 330class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> { 331 ASTWriter &Writer; 332 ASTWriter::RecordData &Record; 333 334public: 335 TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordData &Record) 336 : Writer(Writer), Record(Record) { } 337 338#define ABSTRACT_TYPELOC(CLASS, PARENT) 339#define TYPELOC(CLASS, PARENT) \ 340 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 341#include "clang/AST/TypeLocNodes.def" 342 343 void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); 344 void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); 345}; 346 347} 348 349void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 350 // nothing to do 351} 352void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 353 Writer.AddSourceLocation(TL.getBuiltinLoc(), Record); 354 if (TL.needsExtraLocalData()) { 355 Record.push_back(TL.getWrittenTypeSpec()); 356 Record.push_back(TL.getWrittenSignSpec()); 357 Record.push_back(TL.getWrittenWidthSpec()); 358 Record.push_back(TL.hasModeAttr()); 359 } 360} 361void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { 362 Writer.AddSourceLocation(TL.getNameLoc(), Record); 363} 364void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { 365 Writer.AddSourceLocation(TL.getStarLoc(), Record); 366} 367void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 368 Writer.AddSourceLocation(TL.getCaretLoc(), Record); 369} 370void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 371 Writer.AddSourceLocation(TL.getAmpLoc(), Record); 372} 373void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 374 Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record); 375} 376void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 377 Writer.AddSourceLocation(TL.getStarLoc(), Record); 378} 379void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { 380 Writer.AddSourceLocation(TL.getLBracketLoc(), Record); 381 Writer.AddSourceLocation(TL.getRBracketLoc(), Record); 382 Record.push_back(TL.getSizeExpr() ? 1 : 0); 383 if (TL.getSizeExpr()) 384 Writer.AddStmt(TL.getSizeExpr()); 385} 386void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 387 VisitArrayTypeLoc(TL); 388} 389void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 390 VisitArrayTypeLoc(TL); 391} 392void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 393 VisitArrayTypeLoc(TL); 394} 395void TypeLocWriter::VisitDependentSizedArrayTypeLoc( 396 DependentSizedArrayTypeLoc TL) { 397 VisitArrayTypeLoc(TL); 398} 399void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( 400 DependentSizedExtVectorTypeLoc TL) { 401 Writer.AddSourceLocation(TL.getNameLoc(), Record); 402} 403void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { 404 Writer.AddSourceLocation(TL.getNameLoc(), Record); 405} 406void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 407 Writer.AddSourceLocation(TL.getNameLoc(), Record); 408} 409void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 410 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 411 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 412 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 413 Writer.AddDeclRef(TL.getArg(i), Record); 414} 415void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 416 VisitFunctionTypeLoc(TL); 417} 418void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 419 VisitFunctionTypeLoc(TL); 420} 421void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 422 Writer.AddSourceLocation(TL.getNameLoc(), Record); 423} 424void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 425 Writer.AddSourceLocation(TL.getNameLoc(), Record); 426} 427void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 428 Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 429 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 430 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 431} 432void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 433 Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 434 Writer.AddSourceLocation(TL.getLParenLoc(), Record); 435 Writer.AddSourceLocation(TL.getRParenLoc(), Record); 436 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); 437} 438void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 439 Writer.AddSourceLocation(TL.getNameLoc(), Record); 440} 441void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { 442 Writer.AddSourceLocation(TL.getNameLoc(), Record); 443} 444void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { 445 Writer.AddSourceLocation(TL.getNameLoc(), Record); 446} 447void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 448 Writer.AddSourceLocation(TL.getNameLoc(), Record); 449} 450void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( 451 SubstTemplateTypeParmTypeLoc TL) { 452 Writer.AddSourceLocation(TL.getNameLoc(), Record); 453} 454void TypeLocWriter::VisitTemplateSpecializationTypeLoc( 455 TemplateSpecializationTypeLoc TL) { 456 Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); 457 Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 458 Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 459 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 460 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), 461 TL.getArgLoc(i).getLocInfo(), Record); 462} 463void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 464 Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 465 Writer.AddSourceRange(TL.getQualifierRange(), Record); 466} 467void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 468 Writer.AddSourceLocation(TL.getNameLoc(), Record); 469} 470void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 471 Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 472 Writer.AddSourceRange(TL.getQualifierRange(), Record); 473 Writer.AddSourceLocation(TL.getNameLoc(), Record); 474} 475void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( 476 DependentTemplateSpecializationTypeLoc TL) { 477 Writer.AddSourceLocation(TL.getKeywordLoc(), Record); 478 Writer.AddSourceRange(TL.getQualifierRange(), Record); 479 Writer.AddSourceLocation(TL.getNameLoc(), Record); 480 Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 481 Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 482 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 483 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), 484 TL.getArgLoc(I).getLocInfo(), Record); 485} 486void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 487 Writer.AddSourceLocation(TL.getNameLoc(), Record); 488} 489void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 490 Record.push_back(TL.hasBaseTypeAsWritten()); 491 Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 492 Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 493 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 494 Writer.AddSourceLocation(TL.getProtocolLoc(i), Record); 495} 496void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 497 Writer.AddSourceLocation(TL.getStarLoc(), Record); 498} 499 500//===----------------------------------------------------------------------===// 501// ASTWriter Implementation 502//===----------------------------------------------------------------------===// 503 504static void EmitBlockID(unsigned ID, const char *Name, 505 llvm::BitstreamWriter &Stream, 506 ASTWriter::RecordData &Record) { 507 Record.clear(); 508 Record.push_back(ID); 509 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); 510 511 // Emit the block name if present. 512 if (Name == 0 || Name[0] == 0) return; 513 Record.clear(); 514 while (*Name) 515 Record.push_back(*Name++); 516 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); 517} 518 519static void EmitRecordID(unsigned ID, const char *Name, 520 llvm::BitstreamWriter &Stream, 521 ASTWriter::RecordData &Record) { 522 Record.clear(); 523 Record.push_back(ID); 524 while (*Name) 525 Record.push_back(*Name++); 526 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); 527} 528 529static void AddStmtsExprs(llvm::BitstreamWriter &Stream, 530 ASTWriter::RecordData &Record) { 531#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 532 RECORD(STMT_STOP); 533 RECORD(STMT_NULL_PTR); 534 RECORD(STMT_NULL); 535 RECORD(STMT_COMPOUND); 536 RECORD(STMT_CASE); 537 RECORD(STMT_DEFAULT); 538 RECORD(STMT_LABEL); 539 RECORD(STMT_IF); 540 RECORD(STMT_SWITCH); 541 RECORD(STMT_WHILE); 542 RECORD(STMT_DO); 543 RECORD(STMT_FOR); 544 RECORD(STMT_GOTO); 545 RECORD(STMT_INDIRECT_GOTO); 546 RECORD(STMT_CONTINUE); 547 RECORD(STMT_BREAK); 548 RECORD(STMT_RETURN); 549 RECORD(STMT_DECL); 550 RECORD(STMT_ASM); 551 RECORD(EXPR_PREDEFINED); 552 RECORD(EXPR_DECL_REF); 553 RECORD(EXPR_INTEGER_LITERAL); 554 RECORD(EXPR_FLOATING_LITERAL); 555 RECORD(EXPR_IMAGINARY_LITERAL); 556 RECORD(EXPR_STRING_LITERAL); 557 RECORD(EXPR_CHARACTER_LITERAL); 558 RECORD(EXPR_PAREN); 559 RECORD(EXPR_UNARY_OPERATOR); 560 RECORD(EXPR_SIZEOF_ALIGN_OF); 561 RECORD(EXPR_ARRAY_SUBSCRIPT); 562 RECORD(EXPR_CALL); 563 RECORD(EXPR_MEMBER); 564 RECORD(EXPR_BINARY_OPERATOR); 565 RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); 566 RECORD(EXPR_CONDITIONAL_OPERATOR); 567 RECORD(EXPR_IMPLICIT_CAST); 568 RECORD(EXPR_CSTYLE_CAST); 569 RECORD(EXPR_COMPOUND_LITERAL); 570 RECORD(EXPR_EXT_VECTOR_ELEMENT); 571 RECORD(EXPR_INIT_LIST); 572 RECORD(EXPR_DESIGNATED_INIT); 573 RECORD(EXPR_IMPLICIT_VALUE_INIT); 574 RECORD(EXPR_VA_ARG); 575 RECORD(EXPR_ADDR_LABEL); 576 RECORD(EXPR_STMT); 577 RECORD(EXPR_TYPES_COMPATIBLE); 578 RECORD(EXPR_CHOOSE); 579 RECORD(EXPR_GNU_NULL); 580 RECORD(EXPR_SHUFFLE_VECTOR); 581 RECORD(EXPR_BLOCK); 582 RECORD(EXPR_BLOCK_DECL_REF); 583 RECORD(EXPR_OBJC_STRING_LITERAL); 584 RECORD(EXPR_OBJC_ENCODE); 585 RECORD(EXPR_OBJC_SELECTOR_EXPR); 586 RECORD(EXPR_OBJC_PROTOCOL_EXPR); 587 RECORD(EXPR_OBJC_IVAR_REF_EXPR); 588 RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); 589 RECORD(EXPR_OBJC_KVC_REF_EXPR); 590 RECORD(EXPR_OBJC_MESSAGE_EXPR); 591 RECORD(EXPR_OBJC_SUPER_EXPR); 592 RECORD(STMT_OBJC_FOR_COLLECTION); 593 RECORD(STMT_OBJC_CATCH); 594 RECORD(STMT_OBJC_FINALLY); 595 RECORD(STMT_OBJC_AT_TRY); 596 RECORD(STMT_OBJC_AT_SYNCHRONIZED); 597 RECORD(STMT_OBJC_AT_THROW); 598 RECORD(EXPR_CXX_OPERATOR_CALL); 599 RECORD(EXPR_CXX_CONSTRUCT); 600 RECORD(EXPR_CXX_STATIC_CAST); 601 RECORD(EXPR_CXX_DYNAMIC_CAST); 602 RECORD(EXPR_CXX_REINTERPRET_CAST); 603 RECORD(EXPR_CXX_CONST_CAST); 604 RECORD(EXPR_CXX_FUNCTIONAL_CAST); 605 RECORD(EXPR_CXX_BOOL_LITERAL); 606 RECORD(EXPR_CXX_NULL_PTR_LITERAL); 607#undef RECORD 608} 609 610void ASTWriter::WriteBlockInfoBlock() { 611 RecordData Record; 612 Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); 613 614#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) 615#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 616 617 // AST Top-Level Block. 618 BLOCK(AST_BLOCK); 619 RECORD(ORIGINAL_FILE_NAME); 620 RECORD(TYPE_OFFSET); 621 RECORD(DECL_OFFSET); 622 RECORD(LANGUAGE_OPTIONS); 623 RECORD(METADATA); 624 RECORD(IDENTIFIER_OFFSET); 625 RECORD(IDENTIFIER_TABLE); 626 RECORD(EXTERNAL_DEFINITIONS); 627 RECORD(SPECIAL_TYPES); 628 RECORD(STATISTICS); 629 RECORD(TENTATIVE_DEFINITIONS); 630 RECORD(UNUSED_FILESCOPED_DECLS); 631 RECORD(LOCALLY_SCOPED_EXTERNAL_DECLS); 632 RECORD(SELECTOR_OFFSETS); 633 RECORD(METHOD_POOL); 634 RECORD(PP_COUNTER_VALUE); 635 RECORD(SOURCE_LOCATION_OFFSETS); 636 RECORD(SOURCE_LOCATION_PRELOADS); 637 RECORD(STAT_CACHE); 638 RECORD(EXT_VECTOR_DECLS); 639 RECORD(VERSION_CONTROL_BRANCH_REVISION); 640 RECORD(MACRO_DEFINITION_OFFSETS); 641 RECORD(CHAINED_METADATA); 642 RECORD(REFERENCED_SELECTOR_POOL); 643 644 // SourceManager Block. 645 BLOCK(SOURCE_MANAGER_BLOCK); 646 RECORD(SM_SLOC_FILE_ENTRY); 647 RECORD(SM_SLOC_BUFFER_ENTRY); 648 RECORD(SM_SLOC_BUFFER_BLOB); 649 RECORD(SM_SLOC_INSTANTIATION_ENTRY); 650 RECORD(SM_LINE_TABLE); 651 652 // Preprocessor Block. 653 BLOCK(PREPROCESSOR_BLOCK); 654 RECORD(PP_MACRO_OBJECT_LIKE); 655 RECORD(PP_MACRO_FUNCTION_LIKE); 656 RECORD(PP_TOKEN); 657 RECORD(PP_MACRO_INSTANTIATION); 658 RECORD(PP_MACRO_DEFINITION); 659 660 // Decls and Types block. 661 BLOCK(DECLTYPES_BLOCK); 662 RECORD(TYPE_EXT_QUAL); 663 RECORD(TYPE_COMPLEX); 664 RECORD(TYPE_POINTER); 665 RECORD(TYPE_BLOCK_POINTER); 666 RECORD(TYPE_LVALUE_REFERENCE); 667 RECORD(TYPE_RVALUE_REFERENCE); 668 RECORD(TYPE_MEMBER_POINTER); 669 RECORD(TYPE_CONSTANT_ARRAY); 670 RECORD(TYPE_INCOMPLETE_ARRAY); 671 RECORD(TYPE_VARIABLE_ARRAY); 672 RECORD(TYPE_VECTOR); 673 RECORD(TYPE_EXT_VECTOR); 674 RECORD(TYPE_FUNCTION_PROTO); 675 RECORD(TYPE_FUNCTION_NO_PROTO); 676 RECORD(TYPE_TYPEDEF); 677 RECORD(TYPE_TYPEOF_EXPR); 678 RECORD(TYPE_TYPEOF); 679 RECORD(TYPE_RECORD); 680 RECORD(TYPE_ENUM); 681 RECORD(TYPE_OBJC_INTERFACE); 682 RECORD(TYPE_OBJC_OBJECT); 683 RECORD(TYPE_OBJC_OBJECT_POINTER); 684 RECORD(DECL_ATTR); 685 RECORD(DECL_TRANSLATION_UNIT); 686 RECORD(DECL_TYPEDEF); 687 RECORD(DECL_ENUM); 688 RECORD(DECL_RECORD); 689 RECORD(DECL_ENUM_CONSTANT); 690 RECORD(DECL_FUNCTION); 691 RECORD(DECL_OBJC_METHOD); 692 RECORD(DECL_OBJC_INTERFACE); 693 RECORD(DECL_OBJC_PROTOCOL); 694 RECORD(DECL_OBJC_IVAR); 695 RECORD(DECL_OBJC_AT_DEFS_FIELD); 696 RECORD(DECL_OBJC_CLASS); 697 RECORD(DECL_OBJC_FORWARD_PROTOCOL); 698 RECORD(DECL_OBJC_CATEGORY); 699 RECORD(DECL_OBJC_CATEGORY_IMPL); 700 RECORD(DECL_OBJC_IMPLEMENTATION); 701 RECORD(DECL_OBJC_COMPATIBLE_ALIAS); 702 RECORD(DECL_OBJC_PROPERTY); 703 RECORD(DECL_OBJC_PROPERTY_IMPL); 704 RECORD(DECL_FIELD); 705 RECORD(DECL_VAR); 706 RECORD(DECL_IMPLICIT_PARAM); 707 RECORD(DECL_PARM_VAR); 708 RECORD(DECL_FILE_SCOPE_ASM); 709 RECORD(DECL_BLOCK); 710 RECORD(DECL_CONTEXT_LEXICAL); 711 RECORD(DECL_CONTEXT_VISIBLE); 712 // Statements and Exprs can occur in the Decls and Types block. 713 AddStmtsExprs(Stream, Record); 714#undef RECORD 715#undef BLOCK 716 Stream.ExitBlock(); 717} 718 719/// \brief Adjusts the given filename to only write out the portion of the 720/// filename that is not part of the system root directory. 721/// 722/// \param Filename the file name to adjust. 723/// 724/// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and 725/// the returned filename will be adjusted by this system root. 726/// 727/// \returns either the original filename (if it needs no adjustment) or the 728/// adjusted filename (which points into the @p Filename parameter). 729static const char * 730adjustFilenameForRelocatablePCH(const char *Filename, const char *isysroot) { 731 assert(Filename && "No file name to adjust?"); 732 733 if (!isysroot) 734 return Filename; 735 736 // Verify that the filename and the system root have the same prefix. 737 unsigned Pos = 0; 738 for (; Filename[Pos] && isysroot[Pos]; ++Pos) 739 if (Filename[Pos] != isysroot[Pos]) 740 return Filename; // Prefixes don't match. 741 742 // We hit the end of the filename before we hit the end of the system root. 743 if (!Filename[Pos]) 744 return Filename; 745 746 // If the file name has a '/' at the current position, skip over the '/'. 747 // We distinguish sysroot-based includes from absolute includes by the 748 // absence of '/' at the beginning of sysroot-based includes. 749 if (Filename[Pos] == '/') 750 ++Pos; 751 752 return Filename + Pos; 753} 754 755/// \brief Write the AST metadata (e.g., i686-apple-darwin9). 756void ASTWriter::WriteMetadata(ASTContext &Context, const char *isysroot) { 757 using namespace llvm; 758 759 // Metadata 760 const TargetInfo &Target = Context.Target; 761 BitCodeAbbrev *MetaAbbrev = new BitCodeAbbrev(); 762 MetaAbbrev->Add(BitCodeAbbrevOp( 763 Chain ? CHAINED_METADATA : METADATA)); 764 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST major 765 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST minor 766 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major 767 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor 768 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable 769 // Target triple or chained PCH name 770 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 771 unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev); 772 773 RecordData Record; 774 Record.push_back(Chain ? CHAINED_METADATA : METADATA); 775 Record.push_back(VERSION_MAJOR); 776 Record.push_back(VERSION_MINOR); 777 Record.push_back(CLANG_VERSION_MAJOR); 778 Record.push_back(CLANG_VERSION_MINOR); 779 Record.push_back(isysroot != 0); 780 // FIXME: This writes the absolute path for chained headers. 781 const std::string &BlobStr = Chain ? Chain->getFileName() : Target.getTriple().getTriple(); 782 Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, BlobStr); 783 784 // Original file name 785 SourceManager &SM = Context.getSourceManager(); 786 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 787 BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev(); 788 FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE_NAME)); 789 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 790 unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); 791 792 llvm::sys::Path MainFilePath(MainFile->getName()); 793 794 MainFilePath.makeAbsolute(); 795 796 const char *MainFileNameStr = MainFilePath.c_str(); 797 MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, 798 isysroot); 799 RecordData Record; 800 Record.push_back(ORIGINAL_FILE_NAME); 801 Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr); 802 } 803 804 // Repository branch/version information. 805 BitCodeAbbrev *RepoAbbrev = new BitCodeAbbrev(); 806 RepoAbbrev->Add(BitCodeAbbrevOp(VERSION_CONTROL_BRANCH_REVISION)); 807 RepoAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag 808 unsigned RepoAbbrevCode = Stream.EmitAbbrev(RepoAbbrev); 809 Record.clear(); 810 Record.push_back(VERSION_CONTROL_BRANCH_REVISION); 811 Stream.EmitRecordWithBlob(RepoAbbrevCode, Record, 812 getClangFullRepositoryVersion()); 813} 814 815/// \brief Write the LangOptions structure. 816void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) { 817 RecordData Record; 818 Record.push_back(LangOpts.Trigraphs); 819 Record.push_back(LangOpts.BCPLComment); // BCPL-style '//' comments. 820 Record.push_back(LangOpts.DollarIdents); // '$' allowed in identifiers. 821 Record.push_back(LangOpts.AsmPreprocessor); // Preprocessor in asm mode. 822 Record.push_back(LangOpts.GNUMode); // True in gnu99 mode false in c99 mode (etc) 823 Record.push_back(LangOpts.GNUKeywords); // Allow GNU-extension keywords 824 Record.push_back(LangOpts.ImplicitInt); // C89 implicit 'int'. 825 Record.push_back(LangOpts.Digraphs); // C94, C99 and C++ 826 Record.push_back(LangOpts.HexFloats); // C99 Hexadecimal float constants. 827 Record.push_back(LangOpts.C99); // C99 Support 828 Record.push_back(LangOpts.Microsoft); // Microsoft extensions. 829 Record.push_back(LangOpts.CPlusPlus); // C++ Support 830 Record.push_back(LangOpts.CPlusPlus0x); // C++0x Support 831 Record.push_back(LangOpts.CXXOperatorNames); // Treat C++ operator names as keywords. 832 833 Record.push_back(LangOpts.ObjC1); // Objective-C 1 support enabled. 834 Record.push_back(LangOpts.ObjC2); // Objective-C 2 support enabled. 835 Record.push_back(LangOpts.ObjCNonFragileABI); // Objective-C 836 // modern abi enabled. 837 Record.push_back(LangOpts.ObjCNonFragileABI2); // Objective-C enhanced 838 // modern abi enabled. 839 Record.push_back(LangOpts.NoConstantCFStrings); // non cfstring generation enabled.. 840 841 Record.push_back(LangOpts.PascalStrings); // Allow Pascal strings 842 Record.push_back(LangOpts.WritableStrings); // Allow writable strings 843 Record.push_back(LangOpts.LaxVectorConversions); 844 Record.push_back(LangOpts.AltiVec); 845 Record.push_back(LangOpts.Exceptions); // Support exception handling. 846 Record.push_back(LangOpts.SjLjExceptions); 847 848 Record.push_back(LangOpts.NeXTRuntime); // Use NeXT runtime. 849 Record.push_back(LangOpts.Freestanding); // Freestanding implementation 850 Record.push_back(LangOpts.NoBuiltin); // Do not use builtin functions (-fno-builtin) 851 852 // Whether static initializers are protected by locks. 853 Record.push_back(LangOpts.ThreadsafeStatics); 854 Record.push_back(LangOpts.POSIXThreads); 855 Record.push_back(LangOpts.Blocks); // block extension to C 856 Record.push_back(LangOpts.EmitAllDecls); // Emit all declarations, even if 857 // they are unused. 858 Record.push_back(LangOpts.MathErrno); // Math functions must respect errno 859 // (modulo the platform support). 860 861 Record.push_back(LangOpts.getSignedOverflowBehavior()); 862 Record.push_back(LangOpts.HeinousExtensions); 863 864 Record.push_back(LangOpts.Optimize); // Whether __OPTIMIZE__ should be defined. 865 Record.push_back(LangOpts.OptimizeSize); // Whether __OPTIMIZE_SIZE__ should be 866 // defined. 867 Record.push_back(LangOpts.Static); // Should __STATIC__ be defined (as 868 // opposed to __DYNAMIC__). 869 Record.push_back(LangOpts.PICLevel); // The value for __PIC__, if non-zero. 870 871 Record.push_back(LangOpts.GNUInline); // Should GNU inline semantics be 872 // used (instead of C99 semantics). 873 Record.push_back(LangOpts.NoInline); // Should __NO_INLINE__ be defined. 874 Record.push_back(LangOpts.AccessControl); // Whether C++ access control should 875 // be enabled. 876 Record.push_back(LangOpts.CharIsSigned); // Whether char is a signed or 877 // unsigned type 878 Record.push_back(LangOpts.ShortWChar); // force wchar_t to be unsigned short 879 Record.push_back(LangOpts.getGCMode()); 880 Record.push_back(LangOpts.getVisibilityMode()); 881 Record.push_back(LangOpts.getStackProtectorMode()); 882 Record.push_back(LangOpts.InstantiationDepth); 883 Record.push_back(LangOpts.OpenCL); 884 Record.push_back(LangOpts.CatchUndefined); 885 Record.push_back(LangOpts.ElideConstructors); 886 Record.push_back(LangOpts.SpellChecking); 887 Stream.EmitRecord(LANGUAGE_OPTIONS, Record); 888} 889 890//===----------------------------------------------------------------------===// 891// stat cache Serialization 892//===----------------------------------------------------------------------===// 893 894namespace { 895// Trait used for the on-disk hash table of stat cache results. 896class ASTStatCacheTrait { 897public: 898 typedef const char * key_type; 899 typedef key_type key_type_ref; 900 901 typedef std::pair<int, struct stat> data_type; 902 typedef const data_type& data_type_ref; 903 904 static unsigned ComputeHash(const char *path) { 905 return llvm::HashString(path); 906 } 907 908 std::pair<unsigned,unsigned> 909 EmitKeyDataLength(llvm::raw_ostream& Out, const char *path, 910 data_type_ref Data) { 911 unsigned StrLen = strlen(path); 912 clang::io::Emit16(Out, StrLen); 913 unsigned DataLen = 1; // result value 914 if (Data.first == 0) 915 DataLen += 4 + 4 + 2 + 8 + 8; 916 clang::io::Emit8(Out, DataLen); 917 return std::make_pair(StrLen + 1, DataLen); 918 } 919 920 void EmitKey(llvm::raw_ostream& Out, const char *path, unsigned KeyLen) { 921 Out.write(path, KeyLen); 922 } 923 924 void EmitData(llvm::raw_ostream& Out, key_type_ref, 925 data_type_ref Data, unsigned DataLen) { 926 using namespace clang::io; 927 uint64_t Start = Out.tell(); (void)Start; 928 929 // Result of stat() 930 Emit8(Out, Data.first? 1 : 0); 931 932 if (Data.first == 0) { 933 Emit32(Out, (uint32_t) Data.second.st_ino); 934 Emit32(Out, (uint32_t) Data.second.st_dev); 935 Emit16(Out, (uint16_t) Data.second.st_mode); 936 Emit64(Out, (uint64_t) Data.second.st_mtime); 937 Emit64(Out, (uint64_t) Data.second.st_size); 938 } 939 940 assert(Out.tell() - Start == DataLen && "Wrong data length"); 941 } 942}; 943} // end anonymous namespace 944 945/// \brief Write the stat() system call cache to the AST file. 946void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) { 947 // Build the on-disk hash table containing information about every 948 // stat() call. 949 OnDiskChainedHashTableGenerator<ASTStatCacheTrait> Generator; 950 unsigned NumStatEntries = 0; 951 for (MemorizeStatCalls::iterator Stat = StatCalls.begin(), 952 StatEnd = StatCalls.end(); 953 Stat != StatEnd; ++Stat, ++NumStatEntries) { 954 const char *Filename = Stat->first(); 955 Generator.insert(Filename, Stat->second); 956 } 957 958 // Create the on-disk hash table in a buffer. 959 llvm::SmallString<4096> StatCacheData; 960 uint32_t BucketOffset; 961 { 962 llvm::raw_svector_ostream Out(StatCacheData); 963 // Make sure that no bucket is at offset 0 964 clang::io::Emit32(Out, 0); 965 BucketOffset = Generator.Emit(Out); 966 } 967 968 // Create a blob abbreviation 969 using namespace llvm; 970 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 971 Abbrev->Add(BitCodeAbbrevOp(STAT_CACHE)); 972 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 973 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 974 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 975 unsigned StatCacheAbbrev = Stream.EmitAbbrev(Abbrev); 976 977 // Write the stat cache 978 RecordData Record; 979 Record.push_back(STAT_CACHE); 980 Record.push_back(BucketOffset); 981 Record.push_back(NumStatEntries); 982 Stream.EmitRecordWithBlob(StatCacheAbbrev, Record, StatCacheData.str()); 983} 984 985//===----------------------------------------------------------------------===// 986// Source Manager Serialization 987//===----------------------------------------------------------------------===// 988 989/// \brief Create an abbreviation for the SLocEntry that refers to a 990/// file. 991static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { 992 using namespace llvm; 993 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 994 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); 995 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 996 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 997 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 998 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 999 // FileEntry fields. 1000 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size 1001 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time 1002 // HeaderFileInfo fields. 1003 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isImport 1004 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // DirInfo 1005 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumIncludes 1006 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // ControllingMacro 1007 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1008 return Stream.EmitAbbrev(Abbrev); 1009} 1010 1011/// \brief Create an abbreviation for the SLocEntry that refers to a 1012/// buffer. 1013static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { 1014 using namespace llvm; 1015 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1016 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); 1017 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1018 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1019 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1020 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1021 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob 1022 return Stream.EmitAbbrev(Abbrev); 1023} 1024 1025/// \brief Create an abbreviation for the SLocEntry that refers to a 1026/// buffer's blob. 1027static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { 1028 using namespace llvm; 1029 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1030 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB)); 1031 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob 1032 return Stream.EmitAbbrev(Abbrev); 1033} 1034 1035/// \brief Create an abbreviation for the SLocEntry that refers to an 1036/// buffer. 1037static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &Stream) { 1038 using namespace llvm; 1039 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1040 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_INSTANTIATION_ENTRY)); 1041 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1042 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location 1043 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location 1044 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location 1045 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length 1046 return Stream.EmitAbbrev(Abbrev); 1047} 1048 1049/// \brief Writes the block containing the serialized form of the 1050/// source manager. 1051/// 1052/// TODO: We should probably use an on-disk hash table (stored in a 1053/// blob), indexed based on the file name, so that we only create 1054/// entries for files that we actually need. In the common case (no 1055/// errors), we probably won't have to create file entries for any of 1056/// the files in the AST. 1057void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, 1058 const Preprocessor &PP, 1059 const char *isysroot) { 1060 RecordData Record; 1061 1062 // Enter the source manager block. 1063 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3); 1064 1065 // Abbreviations for the various kinds of source-location entries. 1066 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); 1067 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); 1068 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); 1069 unsigned SLocInstantiationAbbrv = CreateSLocInstantiationAbbrev(Stream); 1070 1071 // Write the line table. 1072 if (SourceMgr.hasLineTable()) { 1073 LineTableInfo &LineTable = SourceMgr.getLineTable(); 1074 1075 // Emit the file names 1076 Record.push_back(LineTable.getNumFilenames()); 1077 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) { 1078 // Emit the file name 1079 const char *Filename = LineTable.getFilename(I); 1080 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1081 unsigned FilenameLen = Filename? strlen(Filename) : 0; 1082 Record.push_back(FilenameLen); 1083 if (FilenameLen) 1084 Record.insert(Record.end(), Filename, Filename + FilenameLen); 1085 } 1086 1087 // Emit the line entries 1088 for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); 1089 L != LEnd; ++L) { 1090 // Emit the file ID 1091 Record.push_back(L->first); 1092 1093 // Emit the line entries 1094 Record.push_back(L->second.size()); 1095 for (std::vector<LineEntry>::iterator LE = L->second.begin(), 1096 LEEnd = L->second.end(); 1097 LE != LEEnd; ++LE) { 1098 Record.push_back(LE->FileOffset); 1099 Record.push_back(LE->LineNo); 1100 Record.push_back(LE->FilenameID); 1101 Record.push_back((unsigned)LE->FileKind); 1102 Record.push_back(LE->IncludeOffset); 1103 } 1104 } 1105 Stream.EmitRecord(SM_LINE_TABLE, Record); 1106 } 1107 1108 // Write out the source location entry table. We skip the first 1109 // entry, which is always the same dummy entry. 1110 std::vector<uint32_t> SLocEntryOffsets; 1111 RecordData PreloadSLocs; 1112 unsigned BaseSLocID = Chain ? Chain->getTotalNumSLocs() : 0; 1113 SLocEntryOffsets.reserve(SourceMgr.sloc_entry_size() - 1 - BaseSLocID); 1114 for (unsigned I = BaseSLocID + 1, N = SourceMgr.sloc_entry_size(); 1115 I != N; ++I) { 1116 // Get this source location entry. 1117 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getSLocEntry(I); 1118 1119 // Record the offset of this source-location entry. 1120 SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); 1121 1122 // Figure out which record code to use. 1123 unsigned Code; 1124 if (SLoc->isFile()) { 1125 if (SLoc->getFile().getContentCache()->Entry) 1126 Code = SM_SLOC_FILE_ENTRY; 1127 else 1128 Code = SM_SLOC_BUFFER_ENTRY; 1129 } else 1130 Code = SM_SLOC_INSTANTIATION_ENTRY; 1131 Record.clear(); 1132 Record.push_back(Code); 1133 1134 Record.push_back(SLoc->getOffset()); 1135 if (SLoc->isFile()) { 1136 const SrcMgr::FileInfo &File = SLoc->getFile(); 1137 Record.push_back(File.getIncludeLoc().getRawEncoding()); 1138 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding 1139 Record.push_back(File.hasLineDirectives()); 1140 1141 const SrcMgr::ContentCache *Content = File.getContentCache(); 1142 if (Content->Entry) { 1143 // The source location entry is a file. The blob associated 1144 // with this entry is the file name. 1145 1146 // Emit size/modification time for this file. 1147 Record.push_back(Content->Entry->getSize()); 1148 Record.push_back(Content->Entry->getModificationTime()); 1149 1150 // Emit header-search information associated with this file. 1151 HeaderFileInfo HFI; 1152 HeaderSearch &HS = PP.getHeaderSearchInfo(); 1153 if (Content->Entry->getUID() < HS.header_file_size()) 1154 HFI = HS.header_file_begin()[Content->Entry->getUID()]; 1155 Record.push_back(HFI.isImport); 1156 Record.push_back(HFI.DirInfo); 1157 Record.push_back(HFI.NumIncludes); 1158 AddIdentifierRef(HFI.ControllingMacro, Record); 1159 1160 // Turn the file name into an absolute path, if it isn't already. 1161 const char *Filename = Content->Entry->getName(); 1162 llvm::sys::Path FilePath(Filename, strlen(Filename)); 1163 FilePath.makeAbsolute(); 1164 Filename = FilePath.c_str(); 1165 1166 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1167 Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename); 1168 1169 // FIXME: For now, preload all file source locations, so that 1170 // we get the appropriate File entries in the reader. This is 1171 // a temporary measure. 1172 PreloadSLocs.push_back(BaseSLocID + SLocEntryOffsets.size()); 1173 } else { 1174 // The source location entry is a buffer. The blob associated 1175 // with this entry contains the contents of the buffer. 1176 1177 // We add one to the size so that we capture the trailing NULL 1178 // that is required by llvm::MemoryBuffer::getMemBuffer (on 1179 // the reader side). 1180 const llvm::MemoryBuffer *Buffer 1181 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 1182 const char *Name = Buffer->getBufferIdentifier(); 1183 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, 1184 llvm::StringRef(Name, strlen(Name) + 1)); 1185 Record.clear(); 1186 Record.push_back(SM_SLOC_BUFFER_BLOB); 1187 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, 1188 llvm::StringRef(Buffer->getBufferStart(), 1189 Buffer->getBufferSize() + 1)); 1190 1191 if (strcmp(Name, "<built-in>") == 0) 1192 PreloadSLocs.push_back(BaseSLocID + SLocEntryOffsets.size()); 1193 } 1194 } else { 1195 // The source location entry is an instantiation. 1196 const SrcMgr::InstantiationInfo &Inst = SLoc->getInstantiation(); 1197 Record.push_back(Inst.getSpellingLoc().getRawEncoding()); 1198 Record.push_back(Inst.getInstantiationLocStart().getRawEncoding()); 1199 Record.push_back(Inst.getInstantiationLocEnd().getRawEncoding()); 1200 1201 // Compute the token length for this macro expansion. 1202 unsigned NextOffset = SourceMgr.getNextOffset(); 1203 if (I + 1 != N) 1204 NextOffset = SourceMgr.getSLocEntry(I + 1).getOffset(); 1205 Record.push_back(NextOffset - SLoc->getOffset() - 1); 1206 Stream.EmitRecordWithAbbrev(SLocInstantiationAbbrv, Record); 1207 } 1208 } 1209 1210 Stream.ExitBlock(); 1211 1212 if (SLocEntryOffsets.empty()) 1213 return; 1214 1215 // Write the source-location offsets table into the AST block. This 1216 // table is used for lazily loading source-location information. 1217 using namespace llvm; 1218 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1219 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); 1220 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs 1221 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // next offset 1222 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets 1223 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); 1224 1225 Record.clear(); 1226 Record.push_back(SOURCE_LOCATION_OFFSETS); 1227 Record.push_back(SLocEntryOffsets.size()); 1228 Record.push_back(SourceMgr.getNextOffset()); 1229 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, 1230 (const char *)data(SLocEntryOffsets), 1231 SLocEntryOffsets.size()*sizeof(SLocEntryOffsets[0])); 1232 1233 // Write the source location entry preloads array, telling the AST 1234 // reader which source locations entries it should load eagerly. 1235 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); 1236} 1237 1238//===----------------------------------------------------------------------===// 1239// Preprocessor Serialization 1240//===----------------------------------------------------------------------===// 1241 1242/// \brief Writes the block containing the serialized form of the 1243/// preprocessor. 1244/// 1245void ASTWriter::WritePreprocessor(const Preprocessor &PP) { 1246 RecordData Record; 1247 1248 // If the preprocessor __COUNTER__ value has been bumped, remember it. 1249 if (PP.getCounterValue() != 0) { 1250 Record.push_back(PP.getCounterValue()); 1251 Stream.EmitRecord(PP_COUNTER_VALUE, Record); 1252 Record.clear(); 1253 } 1254 1255 // Enter the preprocessor block. 1256 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 2); 1257 1258 // If the AST file contains __DATE__ or __TIME__ emit a warning about this. 1259 // FIXME: use diagnostics subsystem for localization etc. 1260 if (PP.SawDateOrTime()) 1261 fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); 1262 1263 // Loop over all the macro definitions that are live at the end of the file, 1264 // emitting each to the PP section. 1265 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 1266 for (Preprocessor::macro_iterator I = PP.macro_begin(), E = PP.macro_end(); 1267 I != E; ++I) { 1268 // FIXME: This emits macros in hash table order, we should do it in a stable 1269 // order so that output is reproducible. 1270 MacroInfo *MI = I->second; 1271 1272 // Don't emit builtin macros like __LINE__ to the AST file unless they have 1273 // been redefined by the header (in which case they are not isBuiltinMacro). 1274 // Also skip macros from a AST file if we're chaining. 1275 if (MI->isBuiltinMacro() || (Chain && MI->isFromAST())) 1276 continue; 1277 1278 AddIdentifierRef(I->first, Record); 1279 MacroOffsets[I->first] = Stream.GetCurrentBitNo(); 1280 Record.push_back(MI->getDefinitionLoc().getRawEncoding()); 1281 Record.push_back(MI->isUsed()); 1282 1283 unsigned Code; 1284 if (MI->isObjectLike()) { 1285 Code = PP_MACRO_OBJECT_LIKE; 1286 } else { 1287 Code = PP_MACRO_FUNCTION_LIKE; 1288 1289 Record.push_back(MI->isC99Varargs()); 1290 Record.push_back(MI->isGNUVarargs()); 1291 Record.push_back(MI->getNumArgs()); 1292 for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end(); 1293 I != E; ++I) 1294 AddIdentifierRef(*I, Record); 1295 } 1296 1297 // If we have a detailed preprocessing record, record the macro definition 1298 // ID that corresponds to this macro. 1299 if (PPRec) 1300 Record.push_back(getMacroDefinitionID(PPRec->findMacroDefinition(MI))); 1301 1302 Stream.EmitRecord(Code, Record); 1303 Record.clear(); 1304 1305 // Emit the tokens array. 1306 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { 1307 // Note that we know that the preprocessor does not have any annotation 1308 // tokens in it because they are created by the parser, and thus can't be 1309 // in a macro definition. 1310 const Token &Tok = MI->getReplacementToken(TokNo); 1311 1312 Record.push_back(Tok.getLocation().getRawEncoding()); 1313 Record.push_back(Tok.getLength()); 1314 1315 // FIXME: When reading literal tokens, reconstruct the literal pointer if 1316 // it is needed. 1317 AddIdentifierRef(Tok.getIdentifierInfo(), Record); 1318 1319 // FIXME: Should translate token kind to a stable encoding. 1320 Record.push_back(Tok.getKind()); 1321 // FIXME: Should translate token flags to a stable encoding. 1322 Record.push_back(Tok.getFlags()); 1323 1324 Stream.EmitRecord(PP_TOKEN, Record); 1325 Record.clear(); 1326 } 1327 ++NumMacros; 1328 } 1329 1330 // If the preprocessor has a preprocessing record, emit it. 1331 unsigned NumPreprocessingRecords = 0; 1332 if (PPRec) { 1333 for (PreprocessingRecord::iterator E = PPRec->begin(), EEnd = PPRec->end(); 1334 E != EEnd; ++E) { 1335 Record.clear(); 1336 1337 if (MacroInstantiation *MI = dyn_cast<MacroInstantiation>(*E)) { 1338 Record.push_back(NumPreprocessingRecords++); 1339 AddSourceLocation(MI->getSourceRange().getBegin(), Record); 1340 AddSourceLocation(MI->getSourceRange().getEnd(), Record); 1341 AddIdentifierRef(MI->getName(), Record); 1342 Record.push_back(getMacroDefinitionID(MI->getDefinition())); 1343 Stream.EmitRecord(PP_MACRO_INSTANTIATION, Record); 1344 continue; 1345 } 1346 1347 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) { 1348 // Record this macro definition's location. 1349 IdentID ID = getMacroDefinitionID(MD); 1350 if (ID != MacroDefinitionOffsets.size()) { 1351 if (ID > MacroDefinitionOffsets.size()) 1352 MacroDefinitionOffsets.resize(ID + 1); 1353 1354 MacroDefinitionOffsets[ID] = Stream.GetCurrentBitNo(); 1355 } else 1356 MacroDefinitionOffsets.push_back(Stream.GetCurrentBitNo()); 1357 1358 Record.push_back(NumPreprocessingRecords++); 1359 Record.push_back(ID); 1360 AddSourceLocation(MD->getSourceRange().getBegin(), Record); 1361 AddSourceLocation(MD->getSourceRange().getEnd(), Record); 1362 AddIdentifierRef(MD->getName(), Record); 1363 AddSourceLocation(MD->getLocation(), Record); 1364 Stream.EmitRecord(PP_MACRO_DEFINITION, Record); 1365 continue; 1366 } 1367 } 1368 } 1369 1370 Stream.ExitBlock(); 1371 1372 // Write the offsets table for the preprocessing record. 1373 if (NumPreprocessingRecords > 0) { 1374 // Write the offsets table for identifier IDs. 1375 using namespace llvm; 1376 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1377 Abbrev->Add(BitCodeAbbrevOp(MACRO_DEFINITION_OFFSETS)); 1378 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of records 1379 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macro defs 1380 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1381 unsigned MacroDefOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1382 1383 Record.clear(); 1384 Record.push_back(MACRO_DEFINITION_OFFSETS); 1385 Record.push_back(NumPreprocessingRecords); 1386 Record.push_back(MacroDefinitionOffsets.size()); 1387 Stream.EmitRecordWithBlob(MacroDefOffsetAbbrev, Record, 1388 (const char *)data(MacroDefinitionOffsets), 1389 MacroDefinitionOffsets.size() * sizeof(uint32_t)); 1390 } 1391} 1392 1393//===----------------------------------------------------------------------===// 1394// Type Serialization 1395//===----------------------------------------------------------------------===// 1396 1397/// \brief Write the representation of a type to the AST stream. 1398void ASTWriter::WriteType(QualType T) { 1399 TypeID &ID = TypeIDs[T]; 1400 if (ID == 0) // we haven't seen this type before. 1401 ID = NextTypeID++; 1402 1403 // Record the offset for this type. 1404 unsigned Index = ID - FirstTypeID; 1405 if (TypeOffsets.size() == Index) 1406 TypeOffsets.push_back(Stream.GetCurrentBitNo()); 1407 else if (TypeOffsets.size() < Index) { 1408 TypeOffsets.resize(Index + 1); 1409 TypeOffsets[Index] = Stream.GetCurrentBitNo(); 1410 } 1411 1412 RecordData Record; 1413 1414 // Emit the type's representation. 1415 ASTTypeWriter W(*this, Record); 1416 1417 if (T.hasLocalNonFastQualifiers()) { 1418 Qualifiers Qs = T.getLocalQualifiers(); 1419 AddTypeRef(T.getLocalUnqualifiedType(), Record); 1420 Record.push_back(Qs.getAsOpaqueValue()); 1421 W.Code = TYPE_EXT_QUAL; 1422 } else { 1423 switch (T->getTypeClass()) { 1424 // For all of the concrete, non-dependent types, call the 1425 // appropriate visitor function. 1426#define TYPE(Class, Base) \ 1427 case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break; 1428#define ABSTRACT_TYPE(Class, Base) 1429#include "clang/AST/TypeNodes.def" 1430 } 1431 } 1432 1433 // Emit the serialized record. 1434 Stream.EmitRecord(W.Code, Record); 1435 1436 // Flush any expressions that were written as part of this type. 1437 FlushStmts(); 1438} 1439 1440//===----------------------------------------------------------------------===// 1441// Declaration Serialization 1442//===----------------------------------------------------------------------===// 1443 1444/// \brief Write the block containing all of the declaration IDs 1445/// lexically declared within the given DeclContext. 1446/// 1447/// \returns the offset of the DECL_CONTEXT_LEXICAL block within the 1448/// bistream, or 0 if no block was written. 1449uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, 1450 DeclContext *DC) { 1451 if (DC->decls_empty()) 1452 return 0; 1453 1454 uint64_t Offset = Stream.GetCurrentBitNo(); 1455 RecordData Record; 1456 Record.push_back(DECL_CONTEXT_LEXICAL); 1457 llvm::SmallVector<DeclID, 64> Decls; 1458 for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end(); 1459 D != DEnd; ++D) 1460 Decls.push_back(GetDeclRef(*D)); 1461 1462 ++NumLexicalDeclContexts; 1463 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, 1464 reinterpret_cast<char*>(Decls.data()), Decls.size() * sizeof(DeclID)); 1465 return Offset; 1466} 1467 1468/// \brief Write the block containing all of the declaration IDs 1469/// visible from the given DeclContext. 1470/// 1471/// \returns the offset of the DECL_CONTEXT_VISIBLE block within the 1472/// bistream, or 0 if no block was written. 1473uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, 1474 DeclContext *DC) { 1475 if (DC->getPrimaryContext() != DC) 1476 return 0; 1477 1478 // Since there is no name lookup into functions or methods, don't bother to 1479 // build a visible-declarations table for these entities. 1480 if (DC->isFunctionOrMethod()) 1481 return 0; 1482 1483 // If not in C++, we perform name lookup for the translation unit via the 1484 // IdentifierInfo chains, don't bother to build a visible-declarations table. 1485 // FIXME: In C++ we need the visible declarations in order to "see" the 1486 // friend declarations, is there a way to do this without writing the table ? 1487 if (DC->isTranslationUnit() && !Context.getLangOptions().CPlusPlus) 1488 return 0; 1489 1490 // Force the DeclContext to build a its name-lookup table. 1491 DC->lookup(DeclarationName()); 1492 1493 // Serialize the contents of the mapping used for lookup. Note that, 1494 // although we have two very different code paths, the serialized 1495 // representation is the same for both cases: a declaration name, 1496 // followed by a size, followed by references to the visible 1497 // declarations that have that name. 1498 uint64_t Offset = Stream.GetCurrentBitNo(); 1499 RecordData Record; 1500 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); 1501 if (!Map) 1502 return 0; 1503 1504 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 1505 D != DEnd; ++D) { 1506 AddDeclarationName(D->first, Record); 1507 DeclContext::lookup_result Result = D->second.getLookupResult(Context); 1508 Record.push_back(Result.second - Result.first); 1509 for (; Result.first != Result.second; ++Result.first) 1510 AddDeclRef(*Result.first, Record); 1511 } 1512 1513 if (Record.size() == 0) 1514 return 0; 1515 1516 Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record); 1517 ++NumVisibleDeclContexts; 1518 return Offset; 1519} 1520 1521void ASTWriter::WriteTypeDeclOffsets() { 1522 using namespace llvm; 1523 RecordData Record; 1524 1525 // Write the type offsets array 1526 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1527 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); 1528 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types 1529 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block 1530 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1531 Record.clear(); 1532 Record.push_back(TYPE_OFFSET); 1533 Record.push_back(TypeOffsets.size()); 1534 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, 1535 (const char *)data(TypeOffsets), 1536 TypeOffsets.size() * sizeof(TypeOffsets[0])); 1537 1538 // Write the declaration offsets array 1539 Abbrev = new BitCodeAbbrev(); 1540 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); 1541 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations 1542 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block 1543 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1544 Record.clear(); 1545 Record.push_back(DECL_OFFSET); 1546 Record.push_back(DeclOffsets.size()); 1547 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, 1548 (const char *)data(DeclOffsets), 1549 DeclOffsets.size() * sizeof(DeclOffsets[0])); 1550} 1551 1552//===----------------------------------------------------------------------===// 1553// Global Method Pool and Selector Serialization 1554//===----------------------------------------------------------------------===// 1555 1556namespace { 1557// Trait used for the on-disk hash table used in the method pool. 1558class ASTMethodPoolTrait { 1559 ASTWriter &Writer; 1560 1561public: 1562 typedef Selector key_type; 1563 typedef key_type key_type_ref; 1564 1565 struct data_type { 1566 SelectorID ID; 1567 ObjCMethodList Instance, Factory; 1568 }; 1569 typedef const data_type& data_type_ref; 1570 1571 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } 1572 1573 static unsigned ComputeHash(Selector Sel) { 1574 unsigned N = Sel.getNumArgs(); 1575 if (N == 0) 1576 ++N; 1577 unsigned R = 5381; 1578 for (unsigned I = 0; I != N; ++I) 1579 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(I)) 1580 R = llvm::HashString(II->getName(), R); 1581 return R; 1582 } 1583 1584 std::pair<unsigned,unsigned> 1585 EmitKeyDataLength(llvm::raw_ostream& Out, Selector Sel, 1586 data_type_ref Methods) { 1587 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); 1588 clang::io::Emit16(Out, KeyLen); 1589 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts 1590 for (const ObjCMethodList *Method = &Methods.Instance; Method; 1591 Method = Method->Next) 1592 if (Method->Method) 1593 DataLen += 4; 1594 for (const ObjCMethodList *Method = &Methods.Factory; Method; 1595 Method = Method->Next) 1596 if (Method->Method) 1597 DataLen += 4; 1598 clang::io::Emit16(Out, DataLen); 1599 return std::make_pair(KeyLen, DataLen); 1600 } 1601 1602 void EmitKey(llvm::raw_ostream& Out, Selector Sel, unsigned) { 1603 uint64_t Start = Out.tell(); 1604 assert((Start >> 32) == 0 && "Selector key offset too large"); 1605 Writer.SetSelectorOffset(Sel, Start); 1606 unsigned N = Sel.getNumArgs(); 1607 clang::io::Emit16(Out, N); 1608 if (N == 0) 1609 N = 1; 1610 for (unsigned I = 0; I != N; ++I) 1611 clang::io::Emit32(Out, 1612 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); 1613 } 1614 1615 void EmitData(llvm::raw_ostream& Out, key_type_ref, 1616 data_type_ref Methods, unsigned DataLen) { 1617 uint64_t Start = Out.tell(); (void)Start; 1618 clang::io::Emit32(Out, Methods.ID); 1619 unsigned NumInstanceMethods = 0; 1620 for (const ObjCMethodList *Method = &Methods.Instance; Method; 1621 Method = Method->Next) 1622 if (Method->Method) 1623 ++NumInstanceMethods; 1624 1625 unsigned NumFactoryMethods = 0; 1626 for (const ObjCMethodList *Method = &Methods.Factory; Method; 1627 Method = Method->Next) 1628 if (Method->Method) 1629 ++NumFactoryMethods; 1630 1631 clang::io::Emit16(Out, NumInstanceMethods); 1632 clang::io::Emit16(Out, NumFactoryMethods); 1633 for (const ObjCMethodList *Method = &Methods.Instance; Method; 1634 Method = Method->Next) 1635 if (Method->Method) 1636 clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 1637 for (const ObjCMethodList *Method = &Methods.Factory; Method; 1638 Method = Method->Next) 1639 if (Method->Method) 1640 clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 1641 1642 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 1643 } 1644}; 1645} // end anonymous namespace 1646 1647/// \brief Write ObjC data: selectors and the method pool. 1648/// 1649/// The method pool contains both instance and factory methods, stored 1650/// in an on-disk hash table indexed by the selector. The hash table also 1651/// contains an empty entry for every other selector known to Sema. 1652void ASTWriter::WriteSelectors(Sema &SemaRef) { 1653 using namespace llvm; 1654 1655 // Do we have to do anything at all? 1656 if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) 1657 return; 1658 unsigned NumTableEntries = 0; 1659 // Create and write out the blob that contains selectors and the method pool. 1660 { 1661 OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator; 1662 1663 // Create the on-disk hash table representation. We walk through every 1664 // selector we've seen and look it up in the method pool. 1665 SelectorOffsets.resize(NextSelectorID - FirstSelectorID); 1666 for (llvm::DenseMap<Selector, SelectorID>::iterator 1667 I = SelectorIDs.begin(), E = SelectorIDs.end(); 1668 I != E; ++I) { 1669 Selector S = I->first; 1670 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); 1671 ASTMethodPoolTrait::data_type Data = { 1672 I->second, 1673 ObjCMethodList(), 1674 ObjCMethodList() 1675 }; 1676 if (F != SemaRef.MethodPool.end()) { 1677 Data.Instance = F->second.first; 1678 Data.Factory = F->second.second; 1679 } 1680 // Only write this selector if it's not in an existing AST or something 1681 // changed. 1682 if (Chain && I->second < FirstSelectorID) { 1683 // Selector already exists. Did it change? 1684 bool changed = false; 1685 for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method; 1686 M = M->Next) { 1687 if (M->Method->getPCHLevel() == 0) 1688 changed = true; 1689 } 1690 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method; 1691 M = M->Next) { 1692 if (M->Method->getPCHLevel() == 0) 1693 changed = true; 1694 } 1695 if (!changed) 1696 continue; 1697 } else if (Data.Instance.Method || Data.Factory.Method) { 1698 // A new method pool entry. 1699 ++NumTableEntries; 1700 } 1701 Generator.insert(S, Data); 1702 } 1703 1704 // Create the on-disk hash table in a buffer. 1705 llvm::SmallString<4096> MethodPool; 1706 uint32_t BucketOffset; 1707 { 1708 ASTMethodPoolTrait Trait(*this); 1709 llvm::raw_svector_ostream Out(MethodPool); 1710 // Make sure that no bucket is at offset 0 1711 clang::io::Emit32(Out, 0); 1712 BucketOffset = Generator.Emit(Out, Trait); 1713 } 1714 1715 // Create a blob abbreviation 1716 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1717 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); 1718 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1719 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1720 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1721 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); 1722 1723 // Write the method pool 1724 RecordData Record; 1725 Record.push_back(METHOD_POOL); 1726 Record.push_back(BucketOffset); 1727 Record.push_back(NumTableEntries); 1728 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str()); 1729 1730 // Create a blob abbreviation for the selector table offsets. 1731 Abbrev = new BitCodeAbbrev(); 1732 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); 1733 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // index 1734 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1735 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1736 1737 // Write the selector offsets table. 1738 Record.clear(); 1739 Record.push_back(SELECTOR_OFFSETS); 1740 Record.push_back(SelectorOffsets.size()); 1741 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, 1742 (const char *)data(SelectorOffsets), 1743 SelectorOffsets.size() * 4); 1744 } 1745} 1746 1747/// \brief Write the selectors referenced in @selector expression into AST file. 1748void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { 1749 using namespace llvm; 1750 if (SemaRef.ReferencedSelectors.empty()) 1751 return; 1752 1753 RecordData Record; 1754 1755 // Note: this writes out all references even for a dependent AST. But it is 1756 // very tricky to fix, and given that @selector shouldn't really appear in 1757 // headers, probably not worth it. It's not a correctness issue. 1758 for (DenseMap<Selector, SourceLocation>::iterator S = 1759 SemaRef.ReferencedSelectors.begin(), 1760 E = SemaRef.ReferencedSelectors.end(); S != E; ++S) { 1761 Selector Sel = (*S).first; 1762 SourceLocation Loc = (*S).second; 1763 AddSelectorRef(Sel, Record); 1764 AddSourceLocation(Loc, Record); 1765 } 1766 Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record); 1767} 1768 1769//===----------------------------------------------------------------------===// 1770// Identifier Table Serialization 1771//===----------------------------------------------------------------------===// 1772 1773namespace { 1774class ASTIdentifierTableTrait { 1775 ASTWriter &Writer; 1776 Preprocessor &PP; 1777 1778 /// \brief Determines whether this is an "interesting" identifier 1779 /// that needs a full IdentifierInfo structure written into the hash 1780 /// table. 1781 static bool isInterestingIdentifier(const IdentifierInfo *II) { 1782 return II->isPoisoned() || 1783 II->isExtensionToken() || 1784 II->hasMacroDefinition() || 1785 II->getObjCOrBuiltinID() || 1786 II->getFETokenInfo<void>(); 1787 } 1788 1789public: 1790 typedef const IdentifierInfo* key_type; 1791 typedef key_type key_type_ref; 1792 1793 typedef IdentID data_type; 1794 typedef data_type data_type_ref; 1795 1796 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP) 1797 : Writer(Writer), PP(PP) { } 1798 1799 static unsigned ComputeHash(const IdentifierInfo* II) { 1800 return llvm::HashString(II->getName()); 1801 } 1802 1803 std::pair<unsigned,unsigned> 1804 EmitKeyDataLength(llvm::raw_ostream& Out, const IdentifierInfo* II, 1805 IdentID ID) { 1806 unsigned KeyLen = II->getLength() + 1; 1807 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 1808 if (isInterestingIdentifier(II)) { 1809 DataLen += 2; // 2 bytes for builtin ID, flags 1810 if (II->hasMacroDefinition() && 1811 !PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro()) 1812 DataLen += 4; 1813 for (IdentifierResolver::iterator D = IdentifierResolver::begin(II), 1814 DEnd = IdentifierResolver::end(); 1815 D != DEnd; ++D) 1816 DataLen += sizeof(DeclID); 1817 } 1818 clang::io::Emit16(Out, DataLen); 1819 // We emit the key length after the data length so that every 1820 // string is preceded by a 16-bit length. This matches the PTH 1821 // format for storing identifiers. 1822 clang::io::Emit16(Out, KeyLen); 1823 return std::make_pair(KeyLen, DataLen); 1824 } 1825 1826 void EmitKey(llvm::raw_ostream& Out, const IdentifierInfo* II, 1827 unsigned KeyLen) { 1828 // Record the location of the key data. This is used when generating 1829 // the mapping from persistent IDs to strings. 1830 Writer.SetIdentifierOffset(II, Out.tell()); 1831 Out.write(II->getNameStart(), KeyLen); 1832 } 1833 1834 void EmitData(llvm::raw_ostream& Out, const IdentifierInfo* II, 1835 IdentID ID, unsigned) { 1836 if (!isInterestingIdentifier(II)) { 1837 clang::io::Emit32(Out, ID << 1); 1838 return; 1839 } 1840 1841 clang::io::Emit32(Out, (ID << 1) | 0x01); 1842 uint32_t Bits = 0; 1843 bool hasMacroDefinition = 1844 II->hasMacroDefinition() && 1845 !PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro(); 1846 Bits = (uint32_t)II->getObjCOrBuiltinID(); 1847 Bits = (Bits << 1) | unsigned(hasMacroDefinition); 1848 Bits = (Bits << 1) | unsigned(II->isExtensionToken()); 1849 Bits = (Bits << 1) | unsigned(II->isPoisoned()); 1850 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); 1851 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); 1852 clang::io::Emit16(Out, Bits); 1853 1854 if (hasMacroDefinition) 1855 clang::io::Emit32(Out, Writer.getMacroOffset(II)); 1856 1857 // Emit the declaration IDs in reverse order, because the 1858 // IdentifierResolver provides the declarations as they would be 1859 // visible (e.g., the function "stat" would come before the struct 1860 // "stat"), but IdentifierResolver::AddDeclToIdentifierChain() 1861 // adds declarations to the end of the list (so we need to see the 1862 // struct "status" before the function "status"). 1863 // Only emit declarations that aren't from a chained PCH, though. 1864 llvm::SmallVector<Decl *, 16> Decls(IdentifierResolver::begin(II), 1865 IdentifierResolver::end()); 1866 for (llvm::SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(), 1867 DEnd = Decls.rend(); 1868 D != DEnd; ++D) 1869 clang::io::Emit32(Out, Writer.getDeclID(*D)); 1870 } 1871}; 1872} // end anonymous namespace 1873 1874/// \brief Write the identifier table into the AST file. 1875/// 1876/// The identifier table consists of a blob containing string data 1877/// (the actual identifiers themselves) and a separate "offsets" index 1878/// that maps identifier IDs to locations within the blob. 1879void ASTWriter::WriteIdentifierTable(Preprocessor &PP) { 1880 using namespace llvm; 1881 1882 // Create and write out the blob that contains the identifier 1883 // strings. 1884 { 1885 OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator; 1886 1887 // Look for any identifiers that were named while processing the 1888 // headers, but are otherwise not needed. We add these to the hash 1889 // table to enable checking of the predefines buffer in the case 1890 // where the user adds new macro definitions when building the AST 1891 // file. 1892 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), 1893 IDEnd = PP.getIdentifierTable().end(); 1894 ID != IDEnd; ++ID) 1895 getIdentifierRef(ID->second); 1896 1897 // Create the on-disk hash table representation. We only store offsets 1898 // for identifiers that appear here for the first time. 1899 IdentifierOffsets.resize(NextIdentID - FirstIdentID); 1900 for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator 1901 ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); 1902 ID != IDEnd; ++ID) { 1903 assert(ID->first && "NULL identifier in identifier table"); 1904 if (!Chain || !ID->first->isFromAST()) 1905 Generator.insert(ID->first, ID->second); 1906 } 1907 1908 // Create the on-disk hash table in a buffer. 1909 llvm::SmallString<4096> IdentifierTable; 1910 uint32_t BucketOffset; 1911 { 1912 ASTIdentifierTableTrait Trait(*this, PP); 1913 llvm::raw_svector_ostream Out(IdentifierTable); 1914 // Make sure that no bucket is at offset 0 1915 clang::io::Emit32(Out, 0); 1916 BucketOffset = Generator.Emit(Out, Trait); 1917 } 1918 1919 // Create a blob abbreviation 1920 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1921 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); 1922 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1923 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1924 unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); 1925 1926 // Write the identifier table 1927 RecordData Record; 1928 Record.push_back(IDENTIFIER_TABLE); 1929 Record.push_back(BucketOffset); 1930 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str()); 1931 } 1932 1933 // Write the offsets table for identifier IDs. 1934 BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1935 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); 1936 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers 1937 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1938 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 1939 1940 RecordData Record; 1941 Record.push_back(IDENTIFIER_OFFSET); 1942 Record.push_back(IdentifierOffsets.size()); 1943 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, 1944 (const char *)data(IdentifierOffsets), 1945 IdentifierOffsets.size() * sizeof(uint32_t)); 1946} 1947 1948//===----------------------------------------------------------------------===// 1949// General Serialization Routines 1950//===----------------------------------------------------------------------===// 1951 1952/// \brief Write a record containing the given attributes. 1953void ASTWriter::WriteAttributeRecord(const AttrVec &Attrs) { 1954 RecordData Record; 1955 for (AttrVec::const_iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){ 1956 const Attr * A = *i; 1957 Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs 1958 AddSourceLocation(A->getLocation(), Record); 1959 Record.push_back(A->isInherited()); 1960 1961#include "clang/Serialization/AttrPCHWrite.inc" 1962 1963 } 1964 1965 Stream.EmitRecord(DECL_ATTR, Record); 1966} 1967 1968void ASTWriter::AddString(const std::string &Str, RecordData &Record) { 1969 Record.push_back(Str.size()); 1970 Record.insert(Record.end(), Str.begin(), Str.end()); 1971} 1972 1973/// \brief Note that the identifier II occurs at the given offset 1974/// within the identifier table. 1975void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { 1976 IdentID ID = IdentifierIDs[II]; 1977 // Only store offsets new to this AST file. Other identifier names are looked 1978 // up earlier in the chain and thus don't need an offset. 1979 if (ID >= FirstIdentID) 1980 IdentifierOffsets[ID - FirstIdentID] = Offset; 1981} 1982 1983/// \brief Note that the selector Sel occurs at the given offset 1984/// within the method pool/selector table. 1985void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { 1986 unsigned ID = SelectorIDs[Sel]; 1987 assert(ID && "Unknown selector"); 1988 // Don't record offsets for selectors that are also available in a different 1989 // file. 1990 if (ID < FirstSelectorID) 1991 return; 1992 SelectorOffsets[ID - FirstSelectorID] = Offset; 1993} 1994 1995ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) 1996 : Stream(Stream), Chain(0), FirstDeclID(1), NextDeclID(FirstDeclID), 1997 FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), 1998 FirstIdentID(1), NextIdentID(FirstIdentID), FirstSelectorID(1), 1999 NextSelectorID(FirstSelectorID), CollectedStmts(&StmtsToEmit), 2000 NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), 2001 NumVisibleDeclContexts(0) { 2002} 2003 2004void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2005 const char *isysroot) { 2006 // Emit the file header. 2007 Stream.Emit((unsigned)'C', 8); 2008 Stream.Emit((unsigned)'P', 8); 2009 Stream.Emit((unsigned)'C', 8); 2010 Stream.Emit((unsigned)'H', 8); 2011 2012 WriteBlockInfoBlock(); 2013 2014 if (Chain) 2015 WriteASTChain(SemaRef, StatCalls, isysroot); 2016 else 2017 WriteASTCore(SemaRef, StatCalls, isysroot); 2018} 2019 2020void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2021 const char *isysroot) { 2022 using namespace llvm; 2023 2024 ASTContext &Context = SemaRef.Context; 2025 Preprocessor &PP = SemaRef.PP; 2026 2027 // The translation unit is the first declaration we'll emit. 2028 DeclIDs[Context.getTranslationUnitDecl()] = 1; 2029 ++NextDeclID; 2030 DeclTypesToEmit.push(Context.getTranslationUnitDecl()); 2031 2032 // Make sure that we emit IdentifierInfos (and any attached 2033 // declarations) for builtins. 2034 { 2035 IdentifierTable &Table = PP.getIdentifierTable(); 2036 llvm::SmallVector<const char *, 32> BuiltinNames; 2037 Context.BuiltinInfo.GetBuiltinNames(BuiltinNames, 2038 Context.getLangOptions().NoBuiltin); 2039 for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) 2040 getIdentifierRef(&Table.get(BuiltinNames[I])); 2041 } 2042 2043 // Build a record containing all of the tentative definitions in this file, in 2044 // TentativeDefinitions order. Generally, this record will be empty for 2045 // headers. 2046 RecordData TentativeDefinitions; 2047 for (unsigned i = 0, e = SemaRef.TentativeDefinitions.size(); i != e; ++i) { 2048 AddDeclRef(SemaRef.TentativeDefinitions[i], TentativeDefinitions); 2049 } 2050 2051 // Build a record containing all of the file scoped decls in this file. 2052 RecordData UnusedFileScopedDecls; 2053 for (unsigned i=0, e = SemaRef.UnusedFileScopedDecls.size(); i !=e; ++i) 2054 AddDeclRef(SemaRef.UnusedFileScopedDecls[i], UnusedFileScopedDecls); 2055 2056 RecordData WeakUndeclaredIdentifiers; 2057 if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { 2058 WeakUndeclaredIdentifiers.push_back( 2059 SemaRef.WeakUndeclaredIdentifiers.size()); 2060 for (llvm::DenseMap<IdentifierInfo*,Sema::WeakInfo>::iterator 2061 I = SemaRef.WeakUndeclaredIdentifiers.begin(), 2062 E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { 2063 AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); 2064 AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); 2065 AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); 2066 WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); 2067 } 2068 } 2069 2070 // Build a record containing all of the locally-scoped external 2071 // declarations in this header file. Generally, this record will be 2072 // empty. 2073 RecordData LocallyScopedExternalDecls; 2074 // FIXME: This is filling in the AST file in densemap order which is 2075 // nondeterminstic! 2076 for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator 2077 TD = SemaRef.LocallyScopedExternalDecls.begin(), 2078 TDEnd = SemaRef.LocallyScopedExternalDecls.end(); 2079 TD != TDEnd; ++TD) 2080 AddDeclRef(TD->second, LocallyScopedExternalDecls); 2081 2082 // Build a record containing all of the ext_vector declarations. 2083 RecordData ExtVectorDecls; 2084 for (unsigned I = 0, N = SemaRef.ExtVectorDecls.size(); I != N; ++I) 2085 AddDeclRef(SemaRef.ExtVectorDecls[I], ExtVectorDecls); 2086 2087 // Build a record containing all of the VTable uses information. 2088 RecordData VTableUses; 2089 if (!SemaRef.VTableUses.empty()) { 2090 VTableUses.push_back(SemaRef.VTableUses.size()); 2091 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 2092 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 2093 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 2094 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 2095 } 2096 } 2097 2098 // Build a record containing all of dynamic classes declarations. 2099 RecordData DynamicClasses; 2100 for (unsigned I = 0, N = SemaRef.DynamicClasses.size(); I != N; ++I) 2101 AddDeclRef(SemaRef.DynamicClasses[I], DynamicClasses); 2102 2103 // Build a record containing all of pending implicit instantiations. 2104 RecordData PendingImplicitInstantiations; 2105 for (std::deque<Sema::PendingImplicitInstantiation>::iterator 2106 I = SemaRef.PendingImplicitInstantiations.begin(), 2107 N = SemaRef.PendingImplicitInstantiations.end(); I != N; ++I) { 2108 AddDeclRef(I->first, PendingImplicitInstantiations); 2109 AddSourceLocation(I->second, PendingImplicitInstantiations); 2110 } 2111 assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 2112 "There are local ones at end of translation unit!"); 2113 2114 // Build a record containing some declaration references. 2115 RecordData SemaDeclRefs; 2116 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { 2117 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 2118 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 2119 } 2120 2121 // Write the remaining AST contents. 2122 RecordData Record; 2123 Stream.EnterSubblock(AST_BLOCK_ID, 5); 2124 WriteMetadata(Context, isysroot); 2125 WriteLanguageOptions(Context.getLangOptions()); 2126 if (StatCalls && !isysroot) 2127 WriteStatCache(*StatCalls); 2128 WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); 2129 // Write the record of special types. 2130 Record.clear(); 2131 2132 AddTypeRef(Context.getBuiltinVaListType(), Record); 2133 AddTypeRef(Context.getObjCIdType(), Record); 2134 AddTypeRef(Context.getObjCSelType(), Record); 2135 AddTypeRef(Context.getObjCProtoType(), Record); 2136 AddTypeRef(Context.getObjCClassType(), Record); 2137 AddTypeRef(Context.getRawCFConstantStringType(), Record); 2138 AddTypeRef(Context.getRawObjCFastEnumerationStateType(), Record); 2139 AddTypeRef(Context.getFILEType(), Record); 2140 AddTypeRef(Context.getjmp_bufType(), Record); 2141 AddTypeRef(Context.getsigjmp_bufType(), Record); 2142 AddTypeRef(Context.ObjCIdRedefinitionType, Record); 2143 AddTypeRef(Context.ObjCClassRedefinitionType, Record); 2144 AddTypeRef(Context.getRawBlockdescriptorType(), Record); 2145 AddTypeRef(Context.getRawBlockdescriptorExtendedType(), Record); 2146 AddTypeRef(Context.ObjCSelRedefinitionType, Record); 2147 AddTypeRef(Context.getRawNSConstantStringType(), Record); 2148 Record.push_back(Context.isInt128Installed()); 2149 Stream.EmitRecord(SPECIAL_TYPES, Record); 2150 2151 // Keep writing types and declarations until all types and 2152 // declarations have been written. 2153 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, 3); 2154 WriteDeclsBlockAbbrevs(); 2155 while (!DeclTypesToEmit.empty()) { 2156 DeclOrType DOT = DeclTypesToEmit.front(); 2157 DeclTypesToEmit.pop(); 2158 if (DOT.isType()) 2159 WriteType(DOT.getType()); 2160 else 2161 WriteDecl(Context, DOT.getDecl()); 2162 } 2163 Stream.ExitBlock(); 2164 2165 WritePreprocessor(PP); 2166 WriteSelectors(SemaRef); 2167 WriteReferencedSelectorsPool(SemaRef); 2168 WriteIdentifierTable(PP); 2169 2170 WriteTypeDeclOffsets(); 2171 2172 // Write the record containing external, unnamed definitions. 2173 if (!ExternalDefinitions.empty()) 2174 Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions); 2175 2176 // Write the record containing tentative definitions. 2177 if (!TentativeDefinitions.empty()) 2178 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 2179 2180 // Write the record containing unused file scoped decls. 2181 if (!UnusedFileScopedDecls.empty()) 2182 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 2183 2184 // Write the record containing weak undeclared identifiers. 2185 if (!WeakUndeclaredIdentifiers.empty()) 2186 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 2187 WeakUndeclaredIdentifiers); 2188 2189 // Write the record containing locally-scoped external definitions. 2190 if (!LocallyScopedExternalDecls.empty()) 2191 Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS, 2192 LocallyScopedExternalDecls); 2193 2194 // Write the record containing ext_vector type names. 2195 if (!ExtVectorDecls.empty()) 2196 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 2197 2198 // Write the record containing VTable uses information. 2199 if (!VTableUses.empty()) 2200 Stream.EmitRecord(VTABLE_USES, VTableUses); 2201 2202 // Write the record containing dynamic classes declarations. 2203 if (!DynamicClasses.empty()) 2204 Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); 2205 2206 // Write the record containing pending implicit instantiations. 2207 if (!PendingImplicitInstantiations.empty()) 2208 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, 2209 PendingImplicitInstantiations); 2210 2211 // Write the record containing declaration references of Sema. 2212 if (!SemaDeclRefs.empty()) 2213 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 2214 2215 // Some simple statistics 2216 Record.clear(); 2217 Record.push_back(NumStatements); 2218 Record.push_back(NumMacros); 2219 Record.push_back(NumLexicalDeclContexts); 2220 Record.push_back(NumVisibleDeclContexts); 2221 Stream.EmitRecord(STATISTICS, Record); 2222 Stream.ExitBlock(); 2223} 2224 2225void ASTWriter::WriteASTChain(Sema &SemaRef, MemorizeStatCalls *StatCalls, 2226 const char *isysroot) { 2227 using namespace llvm; 2228 2229 FirstDeclID += Chain->getTotalNumDecls(); 2230 FirstTypeID += Chain->getTotalNumTypes(); 2231 FirstIdentID += Chain->getTotalNumIdentifiers(); 2232 FirstSelectorID += Chain->getTotalNumSelectors(); 2233 NextDeclID = FirstDeclID; 2234 NextTypeID = FirstTypeID; 2235 NextIdentID = FirstIdentID; 2236 NextSelectorID = FirstSelectorID; 2237 2238 ASTContext &Context = SemaRef.Context; 2239 Preprocessor &PP = SemaRef.PP; 2240 2241 RecordData Record; 2242 Stream.EnterSubblock(AST_BLOCK_ID, 5); 2243 WriteMetadata(Context, isysroot); 2244 if (StatCalls && !isysroot) 2245 WriteStatCache(*StatCalls); 2246 // FIXME: Source manager block should only write new stuff, which could be 2247 // done by tracking the largest ID in the chain 2248 WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); 2249 2250 // The special types are in the chained PCH. 2251 2252 // We don't start with the translation unit, but with its decls that 2253 // don't come from the chained PCH. 2254 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 2255 llvm::SmallVector<DeclID, 64> NewGlobalDecls; 2256 for (DeclContext::decl_iterator I = TU->noload_decls_begin(), 2257 E = TU->noload_decls_end(); 2258 I != E; ++I) { 2259 if ((*I)->getPCHLevel() == 0) 2260 NewGlobalDecls.push_back(GetDeclRef(*I)); 2261 else if ((*I)->isChangedSinceDeserialization()) 2262 (void)GetDeclRef(*I); // Make sure it's written, but don't record it. 2263 } 2264 // We also need to write a lexical updates block for the TU. 2265 llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); 2266 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); 2267 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 2268 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); 2269 Record.clear(); 2270 Record.push_back(TU_UPDATE_LEXICAL); 2271 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, 2272 reinterpret_cast<const char*>(NewGlobalDecls.data()), 2273 NewGlobalDecls.size() * sizeof(DeclID)); 2274 2275 // Build a record containing all of the new tentative definitions in this 2276 // file, in TentativeDefinitions order. 2277 RecordData TentativeDefinitions; 2278 for (unsigned i = 0, e = SemaRef.TentativeDefinitions.size(); i != e; ++i) { 2279 if (SemaRef.TentativeDefinitions[i]->getPCHLevel() == 0) 2280 AddDeclRef(SemaRef.TentativeDefinitions[i], TentativeDefinitions); 2281 } 2282 2283 // Build a record containing all of the file scoped decls in this file. 2284 RecordData UnusedFileScopedDecls; 2285 for (unsigned i=0, e = SemaRef.UnusedFileScopedDecls.size(); i !=e; ++i) { 2286 if (SemaRef.UnusedFileScopedDecls[i]->getPCHLevel() == 0) 2287 AddDeclRef(SemaRef.UnusedFileScopedDecls[i], UnusedFileScopedDecls); 2288 } 2289 2290 // We write the entire table, overwriting the tables from the chain. 2291 RecordData WeakUndeclaredIdentifiers; 2292 if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { 2293 WeakUndeclaredIdentifiers.push_back( 2294 SemaRef.WeakUndeclaredIdentifiers.size()); 2295 for (llvm::DenseMap<IdentifierInfo*,Sema::WeakInfo>::iterator 2296 I = SemaRef.WeakUndeclaredIdentifiers.begin(), 2297 E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { 2298 AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); 2299 AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); 2300 AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); 2301 WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); 2302 } 2303 } 2304 2305 // Build a record containing all of the locally-scoped external 2306 // declarations in this header file. Generally, this record will be 2307 // empty. 2308 RecordData LocallyScopedExternalDecls; 2309 // FIXME: This is filling in the AST file in densemap order which is 2310 // nondeterminstic! 2311 for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator 2312 TD = SemaRef.LocallyScopedExternalDecls.begin(), 2313 TDEnd = SemaRef.LocallyScopedExternalDecls.end(); 2314 TD != TDEnd; ++TD) { 2315 if (TD->second->getPCHLevel() == 0) 2316 AddDeclRef(TD->second, LocallyScopedExternalDecls); 2317 } 2318 2319 // Build a record containing all of the ext_vector declarations. 2320 RecordData ExtVectorDecls; 2321 for (unsigned I = 0, N = SemaRef.ExtVectorDecls.size(); I != N; ++I) { 2322 if (SemaRef.ExtVectorDecls[I]->getPCHLevel() == 0) 2323 AddDeclRef(SemaRef.ExtVectorDecls[I], ExtVectorDecls); 2324 } 2325 2326 // Build a record containing all of the VTable uses information. 2327 // We write everything here, because it's too hard to determine whether 2328 // a use is new to this part. 2329 RecordData VTableUses; 2330 if (!SemaRef.VTableUses.empty()) { 2331 VTableUses.push_back(SemaRef.VTableUses.size()); 2332 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 2333 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 2334 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 2335 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 2336 } 2337 } 2338 2339 // Build a record containing all of dynamic classes declarations. 2340 RecordData DynamicClasses; 2341 for (unsigned I = 0, N = SemaRef.DynamicClasses.size(); I != N; ++I) 2342 if (SemaRef.DynamicClasses[I]->getPCHLevel() == 0) 2343 AddDeclRef(SemaRef.DynamicClasses[I], DynamicClasses); 2344 2345 // Build a record containing all of pending implicit instantiations. 2346 RecordData PendingImplicitInstantiations; 2347 for (std::deque<Sema::PendingImplicitInstantiation>::iterator 2348 I = SemaRef.PendingImplicitInstantiations.begin(), 2349 N = SemaRef.PendingImplicitInstantiations.end(); I != N; ++I) { 2350 if (I->first->getPCHLevel() == 0) { 2351 AddDeclRef(I->first, PendingImplicitInstantiations); 2352 AddSourceLocation(I->second, PendingImplicitInstantiations); 2353 } 2354 } 2355 assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 2356 "There are local ones at end of translation unit!"); 2357 2358 // Build a record containing some declaration references. 2359 // It's not worth the effort to avoid duplication here. 2360 RecordData SemaDeclRefs; 2361 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { 2362 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 2363 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 2364 } 2365 2366 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, 3); 2367 WriteDeclsBlockAbbrevs(); 2368 while (!DeclTypesToEmit.empty()) { 2369 DeclOrType DOT = DeclTypesToEmit.front(); 2370 DeclTypesToEmit.pop(); 2371 if (DOT.isType()) 2372 WriteType(DOT.getType()); 2373 else 2374 WriteDecl(Context, DOT.getDecl()); 2375 } 2376 Stream.ExitBlock(); 2377 2378 WritePreprocessor(PP); 2379 WriteSelectors(SemaRef); 2380 WriteReferencedSelectorsPool(SemaRef); 2381 WriteIdentifierTable(PP); 2382 WriteTypeDeclOffsets(); 2383 2384 /// Build a record containing first declarations from a chained PCH and the 2385 /// most recent declarations in this AST that they point to. 2386 RecordData FirstLatestDeclIDs; 2387 for (FirstLatestDeclMap::iterator 2388 I = FirstLatestDecls.begin(), E = FirstLatestDecls.end(); I != E; ++I) { 2389 assert(I->first->getPCHLevel() > I->second->getPCHLevel() && 2390 "Expected first & second to be in different PCHs"); 2391 AddDeclRef(I->first, FirstLatestDeclIDs); 2392 AddDeclRef(I->second, FirstLatestDeclIDs); 2393 } 2394 if (!FirstLatestDeclIDs.empty()) 2395 Stream.EmitRecord(REDECLS_UPDATE_LATEST, FirstLatestDeclIDs); 2396 2397 // Write the record containing external, unnamed definitions. 2398 if (!ExternalDefinitions.empty()) 2399 Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions); 2400 2401 // Write the record containing tentative definitions. 2402 if (!TentativeDefinitions.empty()) 2403 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 2404 2405 // Write the record containing unused file scoped decls. 2406 if (!UnusedFileScopedDecls.empty()) 2407 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 2408 2409 // Write the record containing weak undeclared identifiers. 2410 if (!WeakUndeclaredIdentifiers.empty()) 2411 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 2412 WeakUndeclaredIdentifiers); 2413 2414 // Write the record containing locally-scoped external definitions. 2415 if (!LocallyScopedExternalDecls.empty()) 2416 Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS, 2417 LocallyScopedExternalDecls); 2418 2419 // Write the record containing ext_vector type names. 2420 if (!ExtVectorDecls.empty()) 2421 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 2422 2423 // Write the record containing VTable uses information. 2424 if (!VTableUses.empty()) 2425 Stream.EmitRecord(VTABLE_USES, VTableUses); 2426 2427 // Write the record containing dynamic classes declarations. 2428 if (!DynamicClasses.empty()) 2429 Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); 2430 2431 // Write the record containing pending implicit instantiations. 2432 if (!PendingImplicitInstantiations.empty()) 2433 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, 2434 PendingImplicitInstantiations); 2435 2436 // Write the record containing declaration references of Sema. 2437 if (!SemaDeclRefs.empty()) 2438 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 2439 2440 Record.clear(); 2441 Record.push_back(NumStatements); 2442 Record.push_back(NumMacros); 2443 Record.push_back(NumLexicalDeclContexts); 2444 Record.push_back(NumVisibleDeclContexts); 2445 WriteDeclUpdateBlock(); 2446 Stream.EmitRecord(STATISTICS, Record); 2447 Stream.ExitBlock(); 2448} 2449 2450void ASTWriter::WriteDeclUpdateBlock() { 2451 if (ReplacedDecls.empty()) 2452 return; 2453 2454 RecordData Record; 2455 for (llvm::SmallVector<std::pair<DeclID, uint64_t>, 16>::iterator 2456 I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { 2457 Record.push_back(I->first); 2458 Record.push_back(I->second); 2459 } 2460 Stream.EmitRecord(DECL_REPLACEMENTS, Record); 2461} 2462 2463void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordData &Record) { 2464 Record.push_back(Loc.getRawEncoding()); 2465} 2466 2467void ASTWriter::AddSourceRange(SourceRange Range, RecordData &Record) { 2468 AddSourceLocation(Range.getBegin(), Record); 2469 AddSourceLocation(Range.getEnd(), Record); 2470} 2471 2472void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordData &Record) { 2473 Record.push_back(Value.getBitWidth()); 2474 unsigned N = Value.getNumWords(); 2475 const uint64_t* Words = Value.getRawData(); 2476 for (unsigned I = 0; I != N; ++I) 2477 Record.push_back(Words[I]); 2478} 2479 2480void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordData &Record) { 2481 Record.push_back(Value.isUnsigned()); 2482 AddAPInt(Value, Record); 2483} 2484 2485void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordData &Record) { 2486 AddAPInt(Value.bitcastToAPInt(), Record); 2487} 2488 2489void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordData &Record) { 2490 Record.push_back(getIdentifierRef(II)); 2491} 2492 2493IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { 2494 if (II == 0) 2495 return 0; 2496 2497 IdentID &ID = IdentifierIDs[II]; 2498 if (ID == 0) 2499 ID = NextIdentID++; 2500 return ID; 2501} 2502 2503IdentID ASTWriter::getMacroDefinitionID(MacroDefinition *MD) { 2504 if (MD == 0) 2505 return 0; 2506 2507 IdentID &ID = MacroDefinitions[MD]; 2508 if (ID == 0) 2509 ID = MacroDefinitions.size(); 2510 return ID; 2511} 2512 2513void ASTWriter::AddSelectorRef(const Selector SelRef, RecordData &Record) { 2514 Record.push_back(getSelectorRef(SelRef)); 2515} 2516 2517SelectorID ASTWriter::getSelectorRef(Selector Sel) { 2518 if (Sel.getAsOpaquePtr() == 0) { 2519 return 0; 2520 } 2521 2522 SelectorID &SID = SelectorIDs[Sel]; 2523 if (SID == 0 && Chain) { 2524 // This might trigger a ReadSelector callback, which will set the ID for 2525 // this selector. 2526 Chain->LoadSelector(Sel); 2527 } 2528 if (SID == 0) { 2529 SID = NextSelectorID++; 2530 } 2531 return SID; 2532} 2533 2534void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordData &Record) { 2535 AddDeclRef(Temp->getDestructor(), Record); 2536} 2537 2538void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, 2539 const TemplateArgumentLocInfo &Arg, 2540 RecordData &Record) { 2541 switch (Kind) { 2542 case TemplateArgument::Expression: 2543 AddStmt(Arg.getAsExpr()); 2544 break; 2545 case TemplateArgument::Type: 2546 AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record); 2547 break; 2548 case TemplateArgument::Template: 2549 AddSourceRange(Arg.getTemplateQualifierRange(), Record); 2550 AddSourceLocation(Arg.getTemplateNameLoc(), Record); 2551 break; 2552 case TemplateArgument::Null: 2553 case TemplateArgument::Integral: 2554 case TemplateArgument::Declaration: 2555 case TemplateArgument::Pack: 2556 break; 2557 } 2558} 2559 2560void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, 2561 RecordData &Record) { 2562 AddTemplateArgument(Arg.getArgument(), Record); 2563 2564 if (Arg.getArgument().getKind() == TemplateArgument::Expression) { 2565 bool InfoHasSameExpr 2566 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); 2567 Record.push_back(InfoHasSameExpr); 2568 if (InfoHasSameExpr) 2569 return; // Avoid storing the same expr twice. 2570 } 2571 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(), 2572 Record); 2573} 2574 2575void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordData &Record) { 2576 if (TInfo == 0) { 2577 AddTypeRef(QualType(), Record); 2578 return; 2579 } 2580 2581 AddTypeRef(TInfo->getType(), Record); 2582 TypeLocWriter TLW(*this, Record); 2583 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 2584 TLW.Visit(TL); 2585} 2586 2587void ASTWriter::AddTypeRef(QualType T, RecordData &Record) { 2588 if (T.isNull()) { 2589 Record.push_back(PREDEF_TYPE_NULL_ID); 2590 return; 2591 } 2592 2593 unsigned FastQuals = T.getLocalFastQualifiers(); 2594 T.removeFastQualifiers(); 2595 2596 if (T.hasLocalNonFastQualifiers()) { 2597 TypeID &ID = TypeIDs[T]; 2598 if (ID == 0) { 2599 // We haven't seen these qualifiers applied to this type before. 2600 // Assign it a new ID. This is the only time we enqueue a 2601 // qualified type, and it has no CV qualifiers. 2602 ID = NextTypeID++; 2603 DeclTypesToEmit.push(T); 2604 } 2605 2606 // Encode the type qualifiers in the type reference. 2607 Record.push_back((ID << Qualifiers::FastWidth) | FastQuals); 2608 return; 2609 } 2610 2611 assert(!T.hasLocalQualifiers()); 2612 2613 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T.getTypePtr())) { 2614 TypeID ID = 0; 2615 switch (BT->getKind()) { 2616 case BuiltinType::Void: ID = PREDEF_TYPE_VOID_ID; break; 2617 case BuiltinType::Bool: ID = PREDEF_TYPE_BOOL_ID; break; 2618 case BuiltinType::Char_U: ID = PREDEF_TYPE_CHAR_U_ID; break; 2619 case BuiltinType::UChar: ID = PREDEF_TYPE_UCHAR_ID; break; 2620 case BuiltinType::UShort: ID = PREDEF_TYPE_USHORT_ID; break; 2621 case BuiltinType::UInt: ID = PREDEF_TYPE_UINT_ID; break; 2622 case BuiltinType::ULong: ID = PREDEF_TYPE_ULONG_ID; break; 2623 case BuiltinType::ULongLong: ID = PREDEF_TYPE_ULONGLONG_ID; break; 2624 case BuiltinType::UInt128: ID = PREDEF_TYPE_UINT128_ID; break; 2625 case BuiltinType::Char_S: ID = PREDEF_TYPE_CHAR_S_ID; break; 2626 case BuiltinType::SChar: ID = PREDEF_TYPE_SCHAR_ID; break; 2627 case BuiltinType::WChar: ID = PREDEF_TYPE_WCHAR_ID; break; 2628 case BuiltinType::Short: ID = PREDEF_TYPE_SHORT_ID; break; 2629 case BuiltinType::Int: ID = PREDEF_TYPE_INT_ID; break; 2630 case BuiltinType::Long: ID = PREDEF_TYPE_LONG_ID; break; 2631 case BuiltinType::LongLong: ID = PREDEF_TYPE_LONGLONG_ID; break; 2632 case BuiltinType::Int128: ID = PREDEF_TYPE_INT128_ID; break; 2633 case BuiltinType::Float: ID = PREDEF_TYPE_FLOAT_ID; break; 2634 case BuiltinType::Double: ID = PREDEF_TYPE_DOUBLE_ID; break; 2635 case BuiltinType::LongDouble: ID = PREDEF_TYPE_LONGDOUBLE_ID; break; 2636 case BuiltinType::NullPtr: ID = PREDEF_TYPE_NULLPTR_ID; break; 2637 case BuiltinType::Char16: ID = PREDEF_TYPE_CHAR16_ID; break; 2638 case BuiltinType::Char32: ID = PREDEF_TYPE_CHAR32_ID; break; 2639 case BuiltinType::Overload: ID = PREDEF_TYPE_OVERLOAD_ID; break; 2640 case BuiltinType::Dependent: ID = PREDEF_TYPE_DEPENDENT_ID; break; 2641 case BuiltinType::ObjCId: ID = PREDEF_TYPE_OBJC_ID; break; 2642 case BuiltinType::ObjCClass: ID = PREDEF_TYPE_OBJC_CLASS; break; 2643 case BuiltinType::ObjCSel: ID = PREDEF_TYPE_OBJC_SEL; break; 2644 case BuiltinType::UndeducedAuto: 2645 assert(0 && "Should not see undeduced auto here"); 2646 break; 2647 } 2648 2649 Record.push_back((ID << Qualifiers::FastWidth) | FastQuals); 2650 return; 2651 } 2652 2653 TypeID &ID = TypeIDs[T]; 2654 if (ID == 0) { 2655 // We haven't seen this type before. Assign it a new ID and put it 2656 // into the queue of types to emit. 2657 ID = NextTypeID++; 2658 DeclTypesToEmit.push(T); 2659 } 2660 2661 // Encode the type qualifiers in the type reference. 2662 Record.push_back((ID << Qualifiers::FastWidth) | FastQuals); 2663} 2664 2665void ASTWriter::AddDeclRef(const Decl *D, RecordData &Record) { 2666 Record.push_back(GetDeclRef(D)); 2667} 2668 2669DeclID ASTWriter::GetDeclRef(const Decl *D) { 2670 if (D == 0) { 2671 return 0; 2672 } 2673 2674 DeclID &ID = DeclIDs[D]; 2675 if (ID == 0) { 2676 // We haven't seen this declaration before. Give it a new ID and 2677 // enqueue it in the list of declarations to emit. 2678 ID = NextDeclID++; 2679 DeclTypesToEmit.push(const_cast<Decl *>(D)); 2680 } else if (ID < FirstDeclID && D->isChangedSinceDeserialization()) { 2681 // We don't add it to the replacement collection here, because we don't 2682 // have the offset yet. 2683 DeclTypesToEmit.push(const_cast<Decl *>(D)); 2684 // Reset the flag, so that we don't add this decl multiple times. 2685 const_cast<Decl *>(D)->setChangedSinceDeserialization(false); 2686 } 2687 2688 return ID; 2689} 2690 2691DeclID ASTWriter::getDeclID(const Decl *D) { 2692 if (D == 0) 2693 return 0; 2694 2695 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); 2696 return DeclIDs[D]; 2697} 2698 2699void ASTWriter::AddDeclarationName(DeclarationName Name, RecordData &Record) { 2700 // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. 2701 Record.push_back(Name.getNameKind()); 2702 switch (Name.getNameKind()) { 2703 case DeclarationName::Identifier: 2704 AddIdentifierRef(Name.getAsIdentifierInfo(), Record); 2705 break; 2706 2707 case DeclarationName::ObjCZeroArgSelector: 2708 case DeclarationName::ObjCOneArgSelector: 2709 case DeclarationName::ObjCMultiArgSelector: 2710 AddSelectorRef(Name.getObjCSelector(), Record); 2711 break; 2712 2713 case DeclarationName::CXXConstructorName: 2714 case DeclarationName::CXXDestructorName: 2715 case DeclarationName::CXXConversionFunctionName: 2716 AddTypeRef(Name.getCXXNameType(), Record); 2717 break; 2718 2719 case DeclarationName::CXXOperatorName: 2720 Record.push_back(Name.getCXXOverloadedOperator()); 2721 break; 2722 2723 case DeclarationName::CXXLiteralOperatorName: 2724 AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record); 2725 break; 2726 2727 case DeclarationName::CXXUsingDirective: 2728 // No extra data to emit 2729 break; 2730 } 2731} 2732 2733void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS, 2734 RecordData &Record) { 2735 // Nested name specifiers usually aren't too long. I think that 8 would 2736 // typically accomodate the vast majority. 2737 llvm::SmallVector<NestedNameSpecifier *, 8> NestedNames; 2738 2739 // Push each of the NNS's onto a stack for serialization in reverse order. 2740 while (NNS) { 2741 NestedNames.push_back(NNS); 2742 NNS = NNS->getPrefix(); 2743 } 2744 2745 Record.push_back(NestedNames.size()); 2746 while(!NestedNames.empty()) { 2747 NNS = NestedNames.pop_back_val(); 2748 NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); 2749 Record.push_back(Kind); 2750 switch (Kind) { 2751 case NestedNameSpecifier::Identifier: 2752 AddIdentifierRef(NNS->getAsIdentifier(), Record); 2753 break; 2754 2755 case NestedNameSpecifier::Namespace: 2756 AddDeclRef(NNS->getAsNamespace(), Record); 2757 break; 2758 2759 case NestedNameSpecifier::TypeSpec: 2760 case NestedNameSpecifier::TypeSpecWithTemplate: 2761 AddTypeRef(QualType(NNS->getAsType(), 0), Record); 2762 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 2763 break; 2764 2765 case NestedNameSpecifier::Global: 2766 // Don't need to write an associated value. 2767 break; 2768 } 2769 } 2770} 2771 2772void ASTWriter::AddTemplateName(TemplateName Name, RecordData &Record) { 2773 TemplateName::NameKind Kind = Name.getKind(); 2774 Record.push_back(Kind); 2775 switch (Kind) { 2776 case TemplateName::Template: 2777 AddDeclRef(Name.getAsTemplateDecl(), Record); 2778 break; 2779 2780 case TemplateName::OverloadedTemplate: { 2781 OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); 2782 Record.push_back(OvT->size()); 2783 for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end(); 2784 I != E; ++I) 2785 AddDeclRef(*I, Record); 2786 break; 2787 } 2788 2789 case TemplateName::QualifiedTemplate: { 2790 QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); 2791 AddNestedNameSpecifier(QualT->getQualifier(), Record); 2792 Record.push_back(QualT->hasTemplateKeyword()); 2793 AddDeclRef(QualT->getTemplateDecl(), Record); 2794 break; 2795 } 2796 2797 case TemplateName::DependentTemplate: { 2798 DependentTemplateName *DepT = Name.getAsDependentTemplateName(); 2799 AddNestedNameSpecifier(DepT->getQualifier(), Record); 2800 Record.push_back(DepT->isIdentifier()); 2801 if (DepT->isIdentifier()) 2802 AddIdentifierRef(DepT->getIdentifier(), Record); 2803 else 2804 Record.push_back(DepT->getOperator()); 2805 break; 2806 } 2807 } 2808} 2809 2810void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, 2811 RecordData &Record) { 2812 Record.push_back(Arg.getKind()); 2813 switch (Arg.getKind()) { 2814 case TemplateArgument::Null: 2815 break; 2816 case TemplateArgument::Type: 2817 AddTypeRef(Arg.getAsType(), Record); 2818 break; 2819 case TemplateArgument::Declaration: 2820 AddDeclRef(Arg.getAsDecl(), Record); 2821 break; 2822 case TemplateArgument::Integral: 2823 AddAPSInt(*Arg.getAsIntegral(), Record); 2824 AddTypeRef(Arg.getIntegralType(), Record); 2825 break; 2826 case TemplateArgument::Template: 2827 AddTemplateName(Arg.getAsTemplate(), Record); 2828 break; 2829 case TemplateArgument::Expression: 2830 AddStmt(Arg.getAsExpr()); 2831 break; 2832 case TemplateArgument::Pack: 2833 Record.push_back(Arg.pack_size()); 2834 for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); 2835 I != E; ++I) 2836 AddTemplateArgument(*I, Record); 2837 break; 2838 } 2839} 2840 2841void 2842ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams, 2843 RecordData &Record) { 2844 assert(TemplateParams && "No TemplateParams!"); 2845 AddSourceLocation(TemplateParams->getTemplateLoc(), Record); 2846 AddSourceLocation(TemplateParams->getLAngleLoc(), Record); 2847 AddSourceLocation(TemplateParams->getRAngleLoc(), Record); 2848 Record.push_back(TemplateParams->size()); 2849 for (TemplateParameterList::const_iterator 2850 P = TemplateParams->begin(), PEnd = TemplateParams->end(); 2851 P != PEnd; ++P) 2852 AddDeclRef(*P, Record); 2853} 2854 2855/// \brief Emit a template argument list. 2856void 2857ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs, 2858 RecordData &Record) { 2859 assert(TemplateArgs && "No TemplateArgs!"); 2860 Record.push_back(TemplateArgs->flat_size()); 2861 for (int i=0, e = TemplateArgs->flat_size(); i != e; ++i) 2862 AddTemplateArgument(TemplateArgs->get(i), Record); 2863} 2864 2865 2866void 2867ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordData &Record) { 2868 Record.push_back(Set.size()); 2869 for (UnresolvedSetImpl::const_iterator 2870 I = Set.begin(), E = Set.end(); I != E; ++I) { 2871 AddDeclRef(I.getDecl(), Record); 2872 Record.push_back(I.getAccess()); 2873 } 2874} 2875 2876void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, 2877 RecordData &Record) { 2878 Record.push_back(Base.isVirtual()); 2879 Record.push_back(Base.isBaseOfClass()); 2880 Record.push_back(Base.getAccessSpecifierAsWritten()); 2881 AddTypeSourceInfo(Base.getTypeSourceInfo(), Record); 2882 AddSourceRange(Base.getSourceRange(), Record); 2883} 2884 2885void ASTWriter::AddCXXBaseOrMemberInitializers( 2886 const CXXBaseOrMemberInitializer * const *BaseOrMembers, 2887 unsigned NumBaseOrMembers, RecordData &Record) { 2888 Record.push_back(NumBaseOrMembers); 2889 for (unsigned i=0; i != NumBaseOrMembers; ++i) { 2890 const CXXBaseOrMemberInitializer *Init = BaseOrMembers[i]; 2891 2892 Record.push_back(Init->isBaseInitializer()); 2893 if (Init->isBaseInitializer()) { 2894 AddTypeSourceInfo(Init->getBaseClassInfo(), Record); 2895 Record.push_back(Init->isBaseVirtual()); 2896 } else { 2897 AddDeclRef(Init->getMember(), Record); 2898 } 2899 AddSourceLocation(Init->getMemberLocation(), Record); 2900 AddStmt(Init->getInit()); 2901 AddDeclRef(Init->getAnonUnionMember(), Record); 2902 AddSourceLocation(Init->getLParenLoc(), Record); 2903 AddSourceLocation(Init->getRParenLoc(), Record); 2904 Record.push_back(Init->isWritten()); 2905 if (Init->isWritten()) { 2906 Record.push_back(Init->getSourceOrder()); 2907 } else { 2908 Record.push_back(Init->getNumArrayIndices()); 2909 for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i) 2910 AddDeclRef(Init->getArrayIndex(i), Record); 2911 } 2912 } 2913} 2914 2915void ASTWriter::SetReader(ASTReader *Reader) { 2916 assert(Reader && "Cannot remove chain"); 2917 assert(FirstDeclID == NextDeclID && 2918 FirstTypeID == NextTypeID && 2919 FirstIdentID == NextIdentID && 2920 FirstSelectorID == NextSelectorID && 2921 "Setting chain after writing has started."); 2922 Chain = Reader; 2923} 2924 2925void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { 2926 IdentifierIDs[II] = ID; 2927} 2928 2929void ASTWriter::TypeRead(TypeID ID, QualType T) { 2930 TypeIDs[T] = ID; 2931} 2932 2933void ASTWriter::DeclRead(DeclID ID, const Decl *D) { 2934 DeclIDs[D] = ID; 2935} 2936 2937void ASTWriter::SelectorRead(SelectorID ID, Selector S) { 2938 SelectorIDs[S] = ID; 2939} 2940