head 1.1; branch 1.1.1; access; symbols netbsd-10-2-RELEASE:1.1.1.15 netbsd-9-5-RELEASE:1.1.1.14 netbsd-11-0-RELEASE:1.1.1.15 netbsd-11-0-RC7:1.1.1.15 netbsd-11-0-RC6:1.1.1.15 netbsd-11-0-RC5:1.1.1.15 netbsd-11-0-RC4:1.1.1.15 netbsd-11-0-RC3:1.1.1.15 netbsd-11-0-RC2:1.1.1.15 netbsd-11-0-RC1:1.1.1.15 perseant-exfatfs-base-20250801:1.1.1.15 netbsd-11:1.1.1.15.0.10 netbsd-11-base:1.1.1.15 netbsd-10-1-RELEASE:1.1.1.15 perseant-exfatfs-base-20240630:1.1.1.15 perseant-exfatfs:1.1.1.15.0.8 perseant-exfatfs-base:1.1.1.15 netbsd-8-3-RELEASE:1.1.1.11 netbsd-9-4-RELEASE:1.1.1.14 netbsd-10-0-RELEASE:1.1.1.15 netbsd-10-0-RC6:1.1.1.15 netbsd-10-0-RC5:1.1.1.15 netbsd-10-0-RC4:1.1.1.15 netbsd-10-0-RC3:1.1.1.15 netbsd-10-0-RC2:1.1.1.15 netbsd-10-0-RC1:1.1.1.15 netbsd-10:1.1.1.15.0.6 netbsd-10-base:1.1.1.15 netbsd-9-3-RELEASE:1.1.1.14 cjep_sun2x:1.1.1.15.0.4 cjep_sun2x-base:1.1.1.15 cjep_staticlib_x-base1:1.1.1.15 netbsd-9-2-RELEASE:1.1.1.14 cjep_staticlib_x:1.1.1.15.0.2 cjep_staticlib_x-base:1.1.1.15 netbsd-9-1-RELEASE:1.1.1.14 phil-wifi-20200421:1.1.1.15 phil-wifi-20200411:1.1.1.15 phil-wifi-20200406:1.1.1.15 netbsd-8-2-RELEASE:1.1.1.11 netbsd-9-0-RELEASE:1.1.1.14 netbsd-9-0-RC2:1.1.1.14 netbsd-9-0-RC1:1.1.1.14 netbsd-9:1.1.1.14.0.2 netbsd-9-base:1.1.1.14 phil-wifi-20190609:1.1.1.14 netbsd-8-1-RELEASE:1.1.1.11 netbsd-8-1-RC1:1.1.1.11 pgoyette-compat-merge-20190127:1.1.1.13.2.1 pgoyette-compat-20190127:1.1.1.14 pgoyette-compat-20190118:1.1.1.14 pgoyette-compat-1226:1.1.1.14 pgoyette-compat-1126:1.1.1.14 pgoyette-compat-1020:1.1.1.14 pgoyette-compat-0930:1.1.1.14 pgoyette-compat-0906:1.1.1.14 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.14 clang-337282:1.1.1.14 netbsd-8-0-RELEASE:1.1.1.11 phil-wifi:1.1.1.13.0.4 phil-wifi-base:1.1.1.13 pgoyette-compat-0625:1.1.1.13 netbsd-8-0-RC2:1.1.1.11 pgoyette-compat-0521:1.1.1.13 pgoyette-compat-0502:1.1.1.13 pgoyette-compat-0422:1.1.1.13 netbsd-8-0-RC1:1.1.1.11 pgoyette-compat-0415:1.1.1.13 pgoyette-compat-0407:1.1.1.13 pgoyette-compat-0330:1.1.1.13 pgoyette-compat-0322:1.1.1.13 pgoyette-compat-0315:1.1.1.13 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.13.0.2 pgoyette-compat-base:1.1.1.13 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.13 matt-nb8-mediatek:1.1.1.11.0.8 matt-nb8-mediatek-base:1.1.1.11 clang-309604:1.1.1.12 perseant-stdc-iso10646:1.1.1.11.0.6 perseant-stdc-iso10646-base:1.1.1.11 netbsd-8:1.1.1.11.0.4 netbsd-8-base:1.1.1.11 prg-localcount2-base3:1.1.1.11 prg-localcount2-base2:1.1.1.11 prg-localcount2-base1:1.1.1.11 prg-localcount2:1.1.1.11.0.2 prg-localcount2-base:1.1.1.11 pgoyette-localcount-20170426:1.1.1.11 bouyer-socketcan-base1:1.1.1.11 pgoyette-localcount-20170320:1.1.1.11 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.11 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.25; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.19; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.05; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.35; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.44; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.26; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.50; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.35.21; author joerg; state Exp; branches 1.1.1.10.2.1; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.02.09.17.38.26; author joerg; state Exp; branches; next 1.1.1.12; commitid UxB8JMFWM7xyMiFz; 1.1.1.12 date 2017.08.01.19.35.36; author joerg; state Exp; branches; next 1.1.1.13; commitid pMuDy65V0VicSx1A; 1.1.1.13 date 2017.12.17.20.59.11; author joerg; state Exp; branches 1.1.1.13.2.1 1.1.1.13.4.1; next 1.1.1.14; commitid T7p9sjiUJyY1UhjA; 1.1.1.14 date 2018.07.17.18.31.25; author joerg; state Exp; branches; next 1.1.1.15; commitid wDzL46ALjrCZgwKA; 1.1.1.15 date 2019.11.13.22.19.28; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.10; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.35; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.30; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.26; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.31; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.41; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.10.2.1 date 2017.04.21.16.51.40; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.13.2.1 date 2018.07.28.04.33.23; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.13.4.1 date 2019.06.10.21.45.28; author christos; state Exp; branches; next 1.1.1.13.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.13.4.2 date 2020.04.13.07.46.38; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- ASTWriter.cpp - AST File Writer ----------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the ASTWriter class, which writes AST files. // //===----------------------------------------------------------------------===// #include "clang/Serialization/ASTWriter.h" #include "ASTCommon.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclContextInternals.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLocVisitor.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/FileSystemStatCache.h" #include "clang/Basic/OnDiskHashTable.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManagerInternals.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Basic/Version.h" #include "clang/Basic/VersionTuple.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/PreprocessingRecord.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/PreprocessorOptions.h" #include "clang/Sema/IdentifierResolver.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/Hashing.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include #include #include #include using namespace clang; using namespace clang::serialization; template static StringRef data(const std::vector &v) { if (v.empty()) return StringRef(); return StringRef(reinterpret_cast(&v[0]), sizeof(T) * v.size()); } template static StringRef data(const SmallVectorImpl &v) { return StringRef(reinterpret_cast(v.data()), sizeof(T) * v.size()); } //===----------------------------------------------------------------------===// // Type serialization //===----------------------------------------------------------------------===// namespace { class ASTTypeWriter { ASTWriter &Writer; ASTWriter::RecordDataImpl &Record; public: /// \brief Type code that corresponds to the record generated. TypeCode Code; ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { } void VisitArrayType(const ArrayType *T); void VisitFunctionType(const FunctionType *T); void VisitTagType(const TagType *T); #define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" }; } void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { llvm_unreachable("Built-in types are never serialized"); } void ASTTypeWriter::VisitComplexType(const ComplexType *T) { Writer.AddTypeRef(T->getElementType(), Record); Code = TYPE_COMPLEX; } void ASTTypeWriter::VisitPointerType(const PointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_POINTER; } void ASTTypeWriter::VisitDecayedType(const DecayedType *T) { Writer.AddTypeRef(T->getOriginalType(), Record); Code = TYPE_DECAYED; } void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_BLOCK_POINTER; } void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); Record.push_back(T->isSpelledAsLValue()); Code = TYPE_LVALUE_REFERENCE; } void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); Code = TYPE_RVALUE_REFERENCE; } void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Writer.AddTypeRef(QualType(T->getClass(), 0), Record); Code = TYPE_MEMBER_POINTER; } void ASTTypeWriter::VisitArrayType(const ArrayType *T) { Writer.AddTypeRef(T->getElementType(), Record); Record.push_back(T->getSizeModifier()); // FIXME: stable values Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values } void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { VisitArrayType(T); Writer.AddAPInt(T->getSize(), Record); Code = TYPE_CONSTANT_ARRAY; } void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { VisitArrayType(T); Code = TYPE_INCOMPLETE_ARRAY; } void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { VisitArrayType(T); Writer.AddSourceLocation(T->getLBracketLoc(), Record); Writer.AddSourceLocation(T->getRBracketLoc(), Record); Writer.AddStmt(T->getSizeExpr()); Code = TYPE_VARIABLE_ARRAY; } void ASTTypeWriter::VisitVectorType(const VectorType *T) { Writer.AddTypeRef(T->getElementType(), Record); Record.push_back(T->getNumElements()); Record.push_back(T->getVectorKind()); Code = TYPE_VECTOR; } void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { VisitVectorType(T); Code = TYPE_EXT_VECTOR; } void ASTTypeWriter::VisitFunctionType(const FunctionType *T) { Writer.AddTypeRef(T->getResultType(), Record); FunctionType::ExtInfo C = T->getExtInfo(); Record.push_back(C.getNoReturn()); Record.push_back(C.getHasRegParm()); Record.push_back(C.getRegParm()); // FIXME: need to stabilize encoding of calling convention... Record.push_back(C.getCC()); Record.push_back(C.getProducesResult()); } void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { VisitFunctionType(T); Code = TYPE_FUNCTION_NO_PROTO; } void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { VisitFunctionType(T); Record.push_back(T->getNumArgs()); for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I) Writer.AddTypeRef(T->getArgType(I), Record); Record.push_back(T->isVariadic()); Record.push_back(T->hasTrailingReturn()); Record.push_back(T->getTypeQuals()); Record.push_back(static_cast(T->getRefQualifier())); Record.push_back(T->getExceptionSpecType()); if (T->getExceptionSpecType() == EST_Dynamic) { Record.push_back(T->getNumExceptions()); for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) Writer.AddTypeRef(T->getExceptionType(I), Record); } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) { Writer.AddStmt(T->getNoexceptExpr()); } else if (T->getExceptionSpecType() == EST_Uninstantiated) { Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record); } else if (T->getExceptionSpecType() == EST_Unevaluated) { Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); } Code = TYPE_FUNCTION_PROTO; } void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { Writer.AddDeclRef(T->getDecl(), Record); Code = TYPE_UNRESOLVED_USING; } void ASTTypeWriter::VisitTypedefType(const TypedefType *T) { Writer.AddDeclRef(T->getDecl(), Record); assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record); Code = TYPE_TYPEDEF; } void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { Writer.AddStmt(T->getUnderlyingExpr()); Code = TYPE_TYPEOF_EXPR; } void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { Writer.AddTypeRef(T->getUnderlyingType(), Record); Code = TYPE_TYPEOF; } void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { Writer.AddTypeRef(T->getUnderlyingType(), Record); Writer.AddStmt(T->getUnderlyingExpr()); Code = TYPE_DECLTYPE; } void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) { Writer.AddTypeRef(T->getBaseType(), Record); Writer.AddTypeRef(T->getUnderlyingType(), Record); Record.push_back(T->getUTTKind()); Code = TYPE_UNARY_TRANSFORM; } void ASTTypeWriter::VisitAutoType(const AutoType *T) { Writer.AddTypeRef(T->getDeducedType(), Record); Record.push_back(T->isDecltypeAuto()); if (T->getDeducedType().isNull()) Record.push_back(T->isDependentType()); Code = TYPE_AUTO; } void ASTTypeWriter::VisitTagType(const TagType *T) { Record.push_back(T->isDependentType()); Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); assert(!T->isBeingDefined() && "Cannot serialize in the middle of a type definition"); } void ASTTypeWriter::VisitRecordType(const RecordType *T) { VisitTagType(T); Code = TYPE_RECORD; } void ASTTypeWriter::VisitEnumType(const EnumType *T) { VisitTagType(T); Code = TYPE_ENUM; } void ASTTypeWriter::VisitAttributedType(const AttributedType *T) { Writer.AddTypeRef(T->getModifiedType(), Record); Writer.AddTypeRef(T->getEquivalentType(), Record); Record.push_back(T->getAttrKind()); Code = TYPE_ATTRIBUTED; } void ASTTypeWriter::VisitSubstTemplateTypeParmType( const SubstTemplateTypeParmType *T) { Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); Writer.AddTypeRef(T->getReplacementType(), Record); Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; } void ASTTypeWriter::VisitSubstTemplateTypeParmPackType( const SubstTemplateTypeParmPackType *T) { Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); Writer.AddTemplateArgument(T->getArgumentPack(), Record); Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK; } void ASTTypeWriter::VisitTemplateSpecializationType( const TemplateSpecializationType *T) { Record.push_back(T->isDependentType()); Writer.AddTemplateName(T->getTemplateName(), Record); Record.push_back(T->getNumArgs()); for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end(); ArgI != ArgE; ++ArgI) Writer.AddTemplateArgument(*ArgI, Record); Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() : T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal(), Record); Code = TYPE_TEMPLATE_SPECIALIZATION; } void ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { VisitArrayType(T); Writer.AddStmt(T->getSizeExpr()); Writer.AddSourceRange(T->getBracketsRange(), Record); Code = TYPE_DEPENDENT_SIZED_ARRAY; } void ASTTypeWriter::VisitDependentSizedExtVectorType( const DependentSizedExtVectorType *T) { // FIXME: Serialize this type (C++ only) llvm_unreachable("Cannot serialize dependent sized extended vector types"); } void ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { Record.push_back(T->getDepth()); Record.push_back(T->getIndex()); Record.push_back(T->isParameterPack()); Writer.AddDeclRef(T->getDecl(), Record); Code = TYPE_TEMPLATE_TYPE_PARM; } void ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddIdentifierRef(T->getIdentifier(), Record); Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal(), Record); Code = TYPE_DEPENDENT_NAME; } void ASTTypeWriter::VisitDependentTemplateSpecializationType( const DependentTemplateSpecializationType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddIdentifierRef(T->getIdentifier(), Record); Record.push_back(T->getNumArgs()); for (DependentTemplateSpecializationType::iterator I = T->begin(), E = T->end(); I != E; ++I) Writer.AddTemplateArgument(*I, Record); Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; } void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { Writer.AddTypeRef(T->getPattern(), Record); if (Optional NumExpansions = T->getNumExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); Code = TYPE_PACK_EXPANSION; } void ASTTypeWriter::VisitParenType(const ParenType *T) { Writer.AddTypeRef(T->getInnerType(), Record); Code = TYPE_PAREN; } void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddTypeRef(T->getNamedType(), Record); Code = TYPE_ELABORATED; } void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); Code = TYPE_INJECTED_CLASS_NAME; } void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Code = TYPE_OBJC_INTERFACE; } void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { Writer.AddTypeRef(T->getBaseType(), Record); Record.push_back(T->getNumProtocols()); for (ObjCObjectType::qual_iterator I = T->qual_begin(), E = T->qual_end(); I != E; ++I) Writer.AddDeclRef(*I, Record); Code = TYPE_OBJC_OBJECT; } void ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_OBJC_OBJECT_POINTER; } void ASTTypeWriter::VisitAtomicType(const AtomicType *T) { Writer.AddTypeRef(T->getValueType(), Record); Code = TYPE_ATOMIC; } namespace { class TypeLocWriter : public TypeLocVisitor { ASTWriter &Writer; ASTWriter::RecordDataImpl &Record; public: TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) : Writer(Writer), Record(Record) { } #define ABSTRACT_TYPELOC(CLASS, PARENT) #define TYPELOC(CLASS, PARENT) \ void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); #include "clang/AST/TypeLocNodes.def" void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); }; } void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { Writer.AddSourceLocation(TL.getBuiltinLoc(), Record); if (TL.needsExtraLocalData()) { Record.push_back(TL.getWrittenTypeSpec()); Record.push_back(TL.getWrittenSignSpec()); Record.push_back(TL.getWrittenWidthSpec()); Record.push_back(TL.hasModeAttr()); } } void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); } void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getCaretLoc(), Record); } void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { Writer.AddSourceLocation(TL.getAmpLoc(), Record); } void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record); } void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record); } void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { Writer.AddSourceLocation(TL.getLBracketLoc(), Record); Writer.AddSourceLocation(TL.getRBracketLoc(), Record); Record.push_back(TL.getSizeExpr() ? 1 : 0); if (TL.getSizeExpr()) Writer.AddStmt(TL.getSizeExpr()); } void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitDependentSizedArrayTypeLoc( DependentSizedArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( DependentSizedExtVectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record); for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) Writer.AddDeclRef(TL.getArg(i), Record); } void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { VisitFunctionTypeLoc(TL); } void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { VisitFunctionTypeLoc(TL); } void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { Writer.AddSourceLocation(TL.getTypeofLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { Writer.AddSourceLocation(TL.getTypeofLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); } void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { Writer.AddSourceLocation(TL.getKWLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); } void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { Writer.AddSourceLocation(TL.getAttrNameLoc(), Record); if (TL.hasAttrOperand()) { SourceRange range = TL.getAttrOperandParensRange(); Writer.AddSourceLocation(range.getBegin(), Record); Writer.AddSourceLocation(range.getEnd(), Record); } if (TL.hasAttrExprOperand()) { Expr *operand = TL.getAttrExprOperand(); Record.push_back(operand ? 1 : 0); if (operand) Writer.AddStmt(operand); } else if (TL.hasAttrEnumOperand()) { Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record); } } void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( SubstTemplateTypeParmTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( SubstTemplateTypeParmPackTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTemplateSpecializationTypeLoc( TemplateSpecializationTypeLoc TL) { Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), TL.getArgLoc(i).getLocInfo(), Record); } void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); } void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( DependentTemplateSpecializationTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), TL.getArgLoc(I).getLocInfo(), Record); } void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { Writer.AddSourceLocation(TL.getEllipsisLoc(), Record); } void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { Record.push_back(TL.hasBaseTypeAsWritten()); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) Writer.AddSourceLocation(TL.getProtocolLoc(i), Record); } void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); } void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) { Writer.AddSourceLocation(TL.getKWLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// static void EmitBlockID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { Record.clear(); Record.push_back(ID); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); // Emit the block name if present. if (Name == 0 || Name[0] == 0) return; Record.clear(); while (*Name) Record.push_back(*Name++); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); } static void EmitRecordID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { Record.clear(); Record.push_back(ID); while (*Name) Record.push_back(*Name++); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); } static void AddStmtsExprs(llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { #define RECORD(X) EmitRecordID(X, #X, Stream, Record) RECORD(STMT_STOP); RECORD(STMT_NULL_PTR); RECORD(STMT_NULL); RECORD(STMT_COMPOUND); RECORD(STMT_CASE); RECORD(STMT_DEFAULT); RECORD(STMT_LABEL); RECORD(STMT_ATTRIBUTED); RECORD(STMT_IF); RECORD(STMT_SWITCH); RECORD(STMT_WHILE); RECORD(STMT_DO); RECORD(STMT_FOR); RECORD(STMT_GOTO); RECORD(STMT_INDIRECT_GOTO); RECORD(STMT_CONTINUE); RECORD(STMT_BREAK); RECORD(STMT_RETURN); RECORD(STMT_DECL); RECORD(STMT_GCCASM); RECORD(STMT_MSASM); RECORD(EXPR_PREDEFINED); RECORD(EXPR_DECL_REF); RECORD(EXPR_INTEGER_LITERAL); RECORD(EXPR_FLOATING_LITERAL); RECORD(EXPR_IMAGINARY_LITERAL); RECORD(EXPR_STRING_LITERAL); RECORD(EXPR_CHARACTER_LITERAL); RECORD(EXPR_PAREN); RECORD(EXPR_UNARY_OPERATOR); RECORD(EXPR_SIZEOF_ALIGN_OF); RECORD(EXPR_ARRAY_SUBSCRIPT); RECORD(EXPR_CALL); RECORD(EXPR_MEMBER); RECORD(EXPR_BINARY_OPERATOR); RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); RECORD(EXPR_CONDITIONAL_OPERATOR); RECORD(EXPR_IMPLICIT_CAST); RECORD(EXPR_CSTYLE_CAST); RECORD(EXPR_COMPOUND_LITERAL); RECORD(EXPR_EXT_VECTOR_ELEMENT); RECORD(EXPR_INIT_LIST); RECORD(EXPR_DESIGNATED_INIT); RECORD(EXPR_IMPLICIT_VALUE_INIT); RECORD(EXPR_VA_ARG); RECORD(EXPR_ADDR_LABEL); RECORD(EXPR_STMT); RECORD(EXPR_CHOOSE); RECORD(EXPR_GNU_NULL); RECORD(EXPR_SHUFFLE_VECTOR); RECORD(EXPR_BLOCK); RECORD(EXPR_GENERIC_SELECTION); RECORD(EXPR_OBJC_STRING_LITERAL); RECORD(EXPR_OBJC_BOXED_EXPRESSION); RECORD(EXPR_OBJC_ARRAY_LITERAL); RECORD(EXPR_OBJC_DICTIONARY_LITERAL); RECORD(EXPR_OBJC_ENCODE); RECORD(EXPR_OBJC_SELECTOR_EXPR); RECORD(EXPR_OBJC_PROTOCOL_EXPR); RECORD(EXPR_OBJC_IVAR_REF_EXPR); RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); RECORD(EXPR_OBJC_KVC_REF_EXPR); RECORD(EXPR_OBJC_MESSAGE_EXPR); RECORD(STMT_OBJC_FOR_COLLECTION); RECORD(STMT_OBJC_CATCH); RECORD(STMT_OBJC_FINALLY); RECORD(STMT_OBJC_AT_TRY); RECORD(STMT_OBJC_AT_SYNCHRONIZED); RECORD(STMT_OBJC_AT_THROW); RECORD(EXPR_OBJC_BOOL_LITERAL); RECORD(EXPR_CXX_OPERATOR_CALL); RECORD(EXPR_CXX_CONSTRUCT); RECORD(EXPR_CXX_STATIC_CAST); RECORD(EXPR_CXX_DYNAMIC_CAST); RECORD(EXPR_CXX_REINTERPRET_CAST); RECORD(EXPR_CXX_CONST_CAST); RECORD(EXPR_CXX_FUNCTIONAL_CAST); RECORD(EXPR_USER_DEFINED_LITERAL); RECORD(EXPR_CXX_STD_INITIALIZER_LIST); RECORD(EXPR_CXX_BOOL_LITERAL); RECORD(EXPR_CXX_NULL_PTR_LITERAL); RECORD(EXPR_CXX_TYPEID_EXPR); RECORD(EXPR_CXX_TYPEID_TYPE); RECORD(EXPR_CXX_UUIDOF_EXPR); RECORD(EXPR_CXX_UUIDOF_TYPE); RECORD(EXPR_CXX_THIS); RECORD(EXPR_CXX_THROW); RECORD(EXPR_CXX_DEFAULT_ARG); RECORD(EXPR_CXX_BIND_TEMPORARY); RECORD(EXPR_CXX_SCALAR_VALUE_INIT); RECORD(EXPR_CXX_NEW); RECORD(EXPR_CXX_DELETE); RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR); RECORD(EXPR_EXPR_WITH_CLEANUPS); RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER); RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF); RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT); RECORD(EXPR_CXX_UNRESOLVED_MEMBER); RECORD(EXPR_CXX_UNRESOLVED_LOOKUP); RECORD(EXPR_CXX_UNARY_TYPE_TRAIT); RECORD(EXPR_CXX_NOEXCEPT); RECORD(EXPR_OPAQUE_VALUE); RECORD(EXPR_BINARY_TYPE_TRAIT); RECORD(EXPR_PACK_EXPANSION); RECORD(EXPR_SIZEOF_PACK); RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK); RECORD(EXPR_CUDA_KERNEL_CALL); #undef RECORD } void ASTWriter::WriteBlockInfoBlock() { RecordData Record; Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) #define RECORD(X) EmitRecordID(X, #X, Stream, Record) // Control Block. BLOCK(CONTROL_BLOCK); RECORD(METADATA); RECORD(IMPORTS); RECORD(LANGUAGE_OPTIONS); RECORD(TARGET_OPTIONS); RECORD(ORIGINAL_FILE); RECORD(ORIGINAL_PCH_DIR); RECORD(ORIGINAL_FILE_ID); RECORD(INPUT_FILE_OFFSETS); RECORD(DIAGNOSTIC_OPTIONS); RECORD(FILE_SYSTEM_OPTIONS); RECORD(HEADER_SEARCH_OPTIONS); RECORD(PREPROCESSOR_OPTIONS); BLOCK(INPUT_FILES_BLOCK); RECORD(INPUT_FILE); // AST Top-Level Block. BLOCK(AST_BLOCK); RECORD(TYPE_OFFSET); RECORD(DECL_OFFSET); RECORD(IDENTIFIER_OFFSET); RECORD(IDENTIFIER_TABLE); RECORD(EXTERNAL_DEFINITIONS); RECORD(SPECIAL_TYPES); RECORD(STATISTICS); RECORD(TENTATIVE_DEFINITIONS); RECORD(UNUSED_FILESCOPED_DECLS); RECORD(LOCALLY_SCOPED_EXTERN_C_DECLS); RECORD(SELECTOR_OFFSETS); RECORD(METHOD_POOL); RECORD(PP_COUNTER_VALUE); RECORD(SOURCE_LOCATION_OFFSETS); RECORD(SOURCE_LOCATION_PRELOADS); RECORD(EXT_VECTOR_DECLS); RECORD(PPD_ENTITIES_OFFSETS); RECORD(REFERENCED_SELECTOR_POOL); RECORD(TU_UPDATE_LEXICAL); RECORD(LOCAL_REDECLARATIONS_MAP); RECORD(SEMA_DECL_REFS); RECORD(WEAK_UNDECLARED_IDENTIFIERS); RECORD(PENDING_IMPLICIT_INSTANTIATIONS); RECORD(DECL_REPLACEMENTS); RECORD(UPDATE_VISIBLE); RECORD(DECL_UPDATE_OFFSETS); RECORD(DECL_UPDATES); RECORD(CXX_BASE_SPECIFIER_OFFSETS); RECORD(DIAG_PRAGMA_MAPPINGS); RECORD(CUDA_SPECIAL_DECL_REFS); RECORD(HEADER_SEARCH_TABLE); RECORD(FP_PRAGMA_OPTIONS); RECORD(OPENCL_EXTENSIONS); RECORD(DELEGATING_CTORS); RECORD(KNOWN_NAMESPACES); RECORD(UNDEFINED_BUT_USED); RECORD(MODULE_OFFSET_MAP); RECORD(SOURCE_MANAGER_LINE_TABLE); RECORD(OBJC_CATEGORIES_MAP); RECORD(FILE_SORTED_DECLS); RECORD(IMPORTED_MODULES); RECORD(MERGED_DECLARATIONS); RECORD(LOCAL_REDECLARATIONS); RECORD(OBJC_CATEGORIES); RECORD(MACRO_OFFSET); RECORD(MACRO_TABLE); RECORD(LATE_PARSED_TEMPLATE); // SourceManager Block. BLOCK(SOURCE_MANAGER_BLOCK); RECORD(SM_SLOC_FILE_ENTRY); RECORD(SM_SLOC_BUFFER_ENTRY); RECORD(SM_SLOC_BUFFER_BLOB); RECORD(SM_SLOC_EXPANSION_ENTRY); // Preprocessor Block. BLOCK(PREPROCESSOR_BLOCK); RECORD(PP_MACRO_OBJECT_LIKE); RECORD(PP_MACRO_FUNCTION_LIKE); RECORD(PP_TOKEN); // Decls and Types block. BLOCK(DECLTYPES_BLOCK); RECORD(TYPE_EXT_QUAL); RECORD(TYPE_COMPLEX); RECORD(TYPE_POINTER); RECORD(TYPE_BLOCK_POINTER); RECORD(TYPE_LVALUE_REFERENCE); RECORD(TYPE_RVALUE_REFERENCE); RECORD(TYPE_MEMBER_POINTER); RECORD(TYPE_CONSTANT_ARRAY); RECORD(TYPE_INCOMPLETE_ARRAY); RECORD(TYPE_VARIABLE_ARRAY); RECORD(TYPE_VECTOR); RECORD(TYPE_EXT_VECTOR); RECORD(TYPE_FUNCTION_PROTO); RECORD(TYPE_FUNCTION_NO_PROTO); RECORD(TYPE_TYPEDEF); RECORD(TYPE_TYPEOF_EXPR); RECORD(TYPE_TYPEOF); RECORD(TYPE_RECORD); RECORD(TYPE_ENUM); RECORD(TYPE_OBJC_INTERFACE); RECORD(TYPE_OBJC_OBJECT); RECORD(TYPE_OBJC_OBJECT_POINTER); RECORD(TYPE_DECLTYPE); RECORD(TYPE_ELABORATED); RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM); RECORD(TYPE_UNRESOLVED_USING); RECORD(TYPE_INJECTED_CLASS_NAME); RECORD(TYPE_OBJC_OBJECT); RECORD(TYPE_TEMPLATE_TYPE_PARM); RECORD(TYPE_TEMPLATE_SPECIALIZATION); RECORD(TYPE_DEPENDENT_NAME); RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION); RECORD(TYPE_DEPENDENT_SIZED_ARRAY); RECORD(TYPE_PAREN); RECORD(TYPE_PACK_EXPANSION); RECORD(TYPE_ATTRIBUTED); RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK); RECORD(TYPE_ATOMIC); RECORD(DECL_TYPEDEF); RECORD(DECL_ENUM); RECORD(DECL_RECORD); RECORD(DECL_ENUM_CONSTANT); RECORD(DECL_FUNCTION); RECORD(DECL_OBJC_METHOD); RECORD(DECL_OBJC_INTERFACE); RECORD(DECL_OBJC_PROTOCOL); RECORD(DECL_OBJC_IVAR); RECORD(DECL_OBJC_AT_DEFS_FIELD); RECORD(DECL_OBJC_CATEGORY); RECORD(DECL_OBJC_CATEGORY_IMPL); RECORD(DECL_OBJC_IMPLEMENTATION); RECORD(DECL_OBJC_COMPATIBLE_ALIAS); RECORD(DECL_OBJC_PROPERTY); RECORD(DECL_OBJC_PROPERTY_IMPL); RECORD(DECL_FIELD); RECORD(DECL_MS_PROPERTY); RECORD(DECL_VAR); RECORD(DECL_IMPLICIT_PARAM); RECORD(DECL_PARM_VAR); RECORD(DECL_FILE_SCOPE_ASM); RECORD(DECL_BLOCK); RECORD(DECL_CONTEXT_LEXICAL); RECORD(DECL_CONTEXT_VISIBLE); RECORD(DECL_NAMESPACE); RECORD(DECL_NAMESPACE_ALIAS); RECORD(DECL_USING); RECORD(DECL_USING_SHADOW); RECORD(DECL_USING_DIRECTIVE); RECORD(DECL_UNRESOLVED_USING_VALUE); RECORD(DECL_UNRESOLVED_USING_TYPENAME); RECORD(DECL_LINKAGE_SPEC); RECORD(DECL_CXX_RECORD); RECORD(DECL_CXX_METHOD); RECORD(DECL_CXX_CONSTRUCTOR); RECORD(DECL_CXX_DESTRUCTOR); RECORD(DECL_CXX_CONVERSION); RECORD(DECL_ACCESS_SPEC); RECORD(DECL_FRIEND); RECORD(DECL_FRIEND_TEMPLATE); RECORD(DECL_CLASS_TEMPLATE); RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION); RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION); RECORD(DECL_VAR_TEMPLATE); RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION); RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION); RECORD(DECL_FUNCTION_TEMPLATE); RECORD(DECL_TEMPLATE_TYPE_PARM); RECORD(DECL_NON_TYPE_TEMPLATE_PARM); RECORD(DECL_TEMPLATE_TEMPLATE_PARM); RECORD(DECL_STATIC_ASSERT); RECORD(DECL_CXX_BASE_SPECIFIERS); RECORD(DECL_INDIRECTFIELD); RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK); // Statements and Exprs can occur in the Decls and Types block. AddStmtsExprs(Stream, Record); BLOCK(PREPROCESSOR_DETAIL_BLOCK); RECORD(PPD_MACRO_EXPANSION); RECORD(PPD_MACRO_DEFINITION); RECORD(PPD_INCLUSION_DIRECTIVE); #undef RECORD #undef BLOCK Stream.ExitBlock(); } /// \brief Adjusts the given filename to only write out the portion of the /// filename that is not part of the system root directory. /// /// \param Filename the file name to adjust. /// /// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and /// the returned filename will be adjusted by this system root. /// /// \returns either the original filename (if it needs no adjustment) or the /// adjusted filename (which points into the @@p Filename parameter). static const char * adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) { assert(Filename && "No file name to adjust?"); if (isysroot.empty()) return Filename; // Verify that the filename and the system root have the same prefix. unsigned Pos = 0; for (; Filename[Pos] && Pos < isysroot.size(); ++Pos) if (Filename[Pos] != isysroot[Pos]) return Filename; // Prefixes don't match. // We hit the end of the filename before we hit the end of the system root. if (!Filename[Pos]) return Filename; // If the file name has a '/' at the current position, skip over the '/'. // We distinguish sysroot-based includes from absolute includes by the // absence of '/' at the beginning of sysroot-based includes. if (Filename[Pos] == '/') ++Pos; return Filename + Pos; } /// \brief Write the control block. void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, StringRef isysroot, const std::string &OutputFile) { using namespace llvm; Stream.EnterSubblock(CONTROL_BLOCK_ID, 5); RecordData Record; // Metadata BitCodeAbbrev *MetadataAbbrev = new BitCodeAbbrev(); MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA)); MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj. MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min. MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev); Record.push_back(METADATA); Record.push_back(VERSION_MAJOR); Record.push_back(VERSION_MINOR); Record.push_back(CLANG_VERSION_MAJOR); Record.push_back(CLANG_VERSION_MINOR); Record.push_back(!isysroot.empty()); Record.push_back(ASTHasCompilerErrors); Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, getClangFullRepositoryVersion()); // Imports if (Chain) { serialization::ModuleManager &Mgr = Chain->getModuleManager(); SmallVector ModulePaths; Record.clear(); for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end(); M != MEnd; ++M) { // Skip modules that weren't directly imported. if (!(*M)->isDirectlyImported()) continue; Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding AddSourceLocation((*M)->ImportLoc, Record); Record.push_back((*M)->File->getSize()); Record.push_back((*M)->File->getModificationTime()); // FIXME: This writes the absolute path for AST files we depend on. const std::string &FileName = (*M)->FileName; Record.push_back(FileName.size()); Record.append(FileName.begin(), FileName.end()); } Stream.EmitRecord(IMPORTS, Record); } // Language options. Record.clear(); const LangOptions &LangOpts = Context.getLangOpts(); #define LANGOPT(Name, Bits, Default, Description) \ Record.push_back(LangOpts.Name); #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ Record.push_back(static_cast(LangOpts.get##Name())); #include "clang/Basic/LangOptions.def" #define SANITIZER(NAME, ID) Record.push_back(LangOpts.Sanitize.ID); #include "clang/Basic/Sanitizers.def" Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind()); AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record); Record.push_back(LangOpts.CurrentModule.size()); Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end()); // Comment options. Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size()); for (CommentOptions::BlockCommandNamesTy::const_iterator I = LangOpts.CommentOpts.BlockCommandNames.begin(), IEnd = LangOpts.CommentOpts.BlockCommandNames.end(); I != IEnd; ++I) { AddString(*I, Record); } Record.push_back(LangOpts.CommentOpts.ParseAllComments); Stream.EmitRecord(LANGUAGE_OPTIONS, Record); // Target options. Record.clear(); const TargetInfo &Target = Context.getTargetInfo(); const TargetOptions &TargetOpts = Target.getTargetOpts(); AddString(TargetOpts.Triple, Record); AddString(TargetOpts.CPU, Record); AddString(TargetOpts.ABI, Record); AddString(TargetOpts.CXXABI, Record); AddString(TargetOpts.LinkerVersion, Record); Record.push_back(TargetOpts.FeaturesAsWritten.size()); for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) { AddString(TargetOpts.FeaturesAsWritten[I], Record); } Record.push_back(TargetOpts.Features.size()); for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) { AddString(TargetOpts.Features[I], Record); } Stream.EmitRecord(TARGET_OPTIONS, Record); // Diagnostic options. Record.clear(); const DiagnosticOptions &DiagOpts = Context.getDiagnostics().getDiagnosticOptions(); #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name); #define ENUM_DIAGOPT(Name, Type, Bits, Default) \ Record.push_back(static_cast(DiagOpts.get##Name())); #include "clang/Basic/DiagnosticOptions.def" Record.push_back(DiagOpts.Warnings.size()); for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I) AddString(DiagOpts.Warnings[I], Record); // Note: we don't serialize the log or serialization file names, because they // are generally transient files and will almost always be overridden. Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record); // File system options. Record.clear(); const FileSystemOptions &FSOpts = Context.getSourceManager().getFileManager().getFileSystemOptions(); AddString(FSOpts.WorkingDir, Record); Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record); // Header search options. Record.clear(); const HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); AddString(HSOpts.Sysroot, Record); // Include entries. Record.push_back(HSOpts.UserEntries.size()); for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) { const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I]; AddString(Entry.Path, Record); Record.push_back(static_cast(Entry.Group)); Record.push_back(Entry.IsFramework); Record.push_back(Entry.IgnoreSysRoot); } // System header prefixes. Record.push_back(HSOpts.SystemHeaderPrefixes.size()); for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) { AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record); Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader); } AddString(HSOpts.ResourceDir, Record); AddString(HSOpts.ModuleCachePath, Record); Record.push_back(HSOpts.DisableModuleHash); Record.push_back(HSOpts.UseBuiltinIncludes); Record.push_back(HSOpts.UseStandardSystemIncludes); Record.push_back(HSOpts.UseStandardCXXIncludes); Record.push_back(HSOpts.UseLibcxx); Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record); // Preprocessor options. Record.clear(); const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts(); // Macro definitions. Record.push_back(PPOpts.Macros.size()); for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { AddString(PPOpts.Macros[I].first, Record); Record.push_back(PPOpts.Macros[I].second); } // Includes Record.push_back(PPOpts.Includes.size()); for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I) AddString(PPOpts.Includes[I], Record); // Macro includes Record.push_back(PPOpts.MacroIncludes.size()); for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I) AddString(PPOpts.MacroIncludes[I], Record); Record.push_back(PPOpts.UsePredefines); // Detailed record is important since it is used for the module cache hash. Record.push_back(PPOpts.DetailedRecord); AddString(PPOpts.ImplicitPCHInclude, Record); AddString(PPOpts.ImplicitPTHInclude, Record); Record.push_back(static_cast(PPOpts.ObjCXXARCStandardLibrary)); Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record); // Original file name and file ID SourceManager &SM = Context.getSourceManager(); if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev(); FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE)); FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); SmallString<128> MainFilePath(MainFile->getName()); llvm::sys::fs::make_absolute(MainFilePath); const char *MainFileNameStr = MainFilePath.c_str(); MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, isysroot); Record.clear(); Record.push_back(ORIGINAL_FILE); Record.push_back(SM.getMainFileID().getOpaqueValue()); Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr); } Record.clear(); Record.push_back(SM.getMainFileID().getOpaqueValue()); Stream.EmitRecord(ORIGINAL_FILE_ID, Record); // Original PCH directory if (!OutputFile.empty() && OutputFile != "-") { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); SmallString<128> OutputPath(OutputFile); llvm::sys::fs::make_absolute(OutputPath); StringRef origDir = llvm::sys::path::parent_path(OutputPath); RecordData Record; Record.push_back(ORIGINAL_PCH_DIR); Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); } WriteInputFiles(Context.SourceMgr, PP.getHeaderSearchInfo().getHeaderSearchOpts(), isysroot, PP.getLangOpts().Modules); Stream.ExitBlock(); } namespace { /// \brief An input file. struct InputFileEntry { const FileEntry *File; bool IsSystemFile; bool BufferOverridden; }; } void ASTWriter::WriteInputFiles(SourceManager &SourceMgr, HeaderSearchOptions &HSOpts, StringRef isysroot, bool Modules) { using namespace llvm; Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4); RecordData Record; // Create input-file abbreviation. BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev(); IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE)); IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev); // Get all ContentCache objects for files, sorted by whether the file is a // system one or not. System files go at the back, users files at the front. std::deque SortedFiles; for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { // Get this source location entry. const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc); // We only care about file entries that were not overridden. if (!SLoc->isFile()) continue; const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); if (!Cache->OrigEntry) continue; InputFileEntry Entry; Entry.File = Cache->OrigEntry; Entry.IsSystemFile = Cache->IsSystemFile; Entry.BufferOverridden = Cache->BufferOverridden; if (Cache->IsSystemFile) SortedFiles.push_back(Entry); else SortedFiles.push_front(Entry); } // If we have an isysroot for a Darwin SDK, include its SDKSettings.plist in // the set of (non-system) input files. This is simple heuristic for // detecting whether the system headers may have changed, because it is too // expensive to stat() all of the system headers. FileManager &FileMgr = SourceMgr.getFileManager(); if (!HSOpts.Sysroot.empty() && !Chain) { llvm::SmallString<128> SDKSettingsFileName(HSOpts.Sysroot); llvm::sys::path::append(SDKSettingsFileName, "SDKSettings.plist"); if (const FileEntry *SDKSettingsFile = FileMgr.getFile(SDKSettingsFileName)) { InputFileEntry Entry = { SDKSettingsFile, false, false }; SortedFiles.push_front(Entry); } } // Add the compiler's own module.map in the set of (non-system) input files. // This is a simple heuristic for detecting whether the compiler's headers // have changed, because we don't want to stat() all of them. if (Modules && !Chain) { SmallString<128> P = StringRef(HSOpts.ResourceDir); llvm::sys::path::append(P, "include"); llvm::sys::path::append(P, "module.map"); if (const FileEntry *ModuleMapFile = FileMgr.getFile(P)) { InputFileEntry Entry = { ModuleMapFile, false, false }; SortedFiles.push_front(Entry); } } unsigned UserFilesNum = 0; // Write out all of the input files. std::vector InputFileOffsets; for (std::deque::iterator I = SortedFiles.begin(), E = SortedFiles.end(); I != E; ++I) { const InputFileEntry &Entry = *I; uint32_t &InputFileID = InputFileIDs[Entry.File]; if (InputFileID != 0) continue; // already recorded this file. // Record this entry's offset. InputFileOffsets.push_back(Stream.GetCurrentBitNo()); InputFileID = InputFileOffsets.size(); if (!Entry.IsSystemFile) ++UserFilesNum; Record.clear(); Record.push_back(INPUT_FILE); Record.push_back(InputFileOffsets.size()); // Emit size/modification time for this file. Record.push_back(Entry.File->getSize()); Record.push_back(Entry.File->getModificationTime()); // Whether this file was overridden. Record.push_back(Entry.BufferOverridden); // Turn the file name into an absolute path, if it isn't already. const char *Filename = Entry.File->getName(); SmallString<128> FilePath(Filename); // Ask the file manager to fixup the relative path for us. This will // honor the working directory. FileMgr.FixupRelativePath(FilePath); // FIXME: This call to make_absolute shouldn't be necessary, the // call to FixupRelativePath should always return an absolute path. llvm::sys::fs::make_absolute(FilePath); Filename = FilePath.c_str(); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); Stream.EmitRecordWithBlob(IFAbbrevCode, Record, Filename); } Stream.ExitBlock(); // Create input file offsets abbreviation. BitCodeAbbrev *OffsetsAbbrev = new BitCodeAbbrev(); OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS)); OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system // input files OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev); // Write input file offsets. Record.clear(); Record.push_back(INPUT_FILE_OFFSETS); Record.push_back(InputFileOffsets.size()); Record.push_back(UserFilesNum); Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, data(InputFileOffsets)); } //===----------------------------------------------------------------------===// // Source Manager Serialization //===----------------------------------------------------------------------===// /// \brief Create an abbreviation for the SLocEntry that refers to a /// file. static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives // FileEntry fields. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer. static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer's blob. static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a macro /// expansion. static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length return Stream.EmitAbbrev(Abbrev); } namespace { // Trait used for the on-disk hash table of header search information. class HeaderFileInfoTrait { ASTWriter &Writer; const HeaderSearch &HS; // Keep track of the framework names we've used during serialization. SmallVector FrameworkStringData; llvm::StringMap FrameworkNameOffset; public: HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS) : Writer(Writer), HS(HS) { } struct key_type { const FileEntry *FE; const char *Filename; }; typedef const key_type &key_type_ref; typedef HeaderFileInfo data_type; typedef const data_type &data_type_ref; static unsigned ComputeHash(key_type_ref key) { // The hash is based only on size/time of the file, so that the reader can // match even when symlinking or excess path elements ("foo/../", "../") // change the form of the name. However, complete path is still the key. return llvm::hash_combine(key.FE->getSize(), key.FE->getModificationTime()); } std::pair EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) { unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8; clang::io::Emit16(Out, KeyLen); unsigned DataLen = 1 + 2 + 4 + 4; if (Data.isModuleHeader) DataLen += 4; clang::io::Emit8(Out, DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) { clang::io::Emit64(Out, key.FE->getSize()); KeyLen -= 8; clang::io::Emit64(Out, key.FE->getModificationTime()); KeyLen -= 8; Out.write(key.Filename, KeyLen); } void EmitData(raw_ostream &Out, key_type_ref key, data_type_ref Data, unsigned DataLen) { using namespace clang::io; uint64_t Start = Out.tell(); (void)Start; unsigned char Flags = (Data.HeaderRole << 6) | (Data.isImport << 5) | (Data.isPragmaOnce << 4) | (Data.DirInfo << 2) | (Data.Resolved << 1) | Data.IndexHeaderMapHeader; Emit8(Out, (uint8_t)Flags); Emit16(Out, (uint16_t) Data.NumIncludes); if (!Data.ControllingMacro) Emit32(Out, (uint32_t)Data.ControllingMacroID); else Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro)); unsigned Offset = 0; if (!Data.Framework.empty()) { // If this header refers into a framework, save the framework name. llvm::StringMap::iterator Pos = FrameworkNameOffset.find(Data.Framework); if (Pos == FrameworkNameOffset.end()) { Offset = FrameworkStringData.size() + 1; FrameworkStringData.append(Data.Framework.begin(), Data.Framework.end()); FrameworkStringData.push_back(0); FrameworkNameOffset[Data.Framework] = Offset; } else Offset = Pos->second; } Emit32(Out, Offset); if (Data.isModuleHeader) { Module *Mod = HS.findModuleForHeader(key.FE).getModule(); Emit32(Out, Writer.getExistingSubmoduleID(Mod)); } assert(Out.tell() - Start == DataLen && "Wrong data length"); } const char *strings_begin() const { return FrameworkStringData.begin(); } const char *strings_end() const { return FrameworkStringData.end(); } }; } // end anonymous namespace /// \brief Write the header search block for the list of files that /// /// \param HS The header search structure to save. void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) { SmallVector FilesByUID; HS.getFileMgr().GetUniqueIDMapping(FilesByUID); if (FilesByUID.size() > HS.header_file_size()) FilesByUID.resize(HS.header_file_size()); HeaderFileInfoTrait GeneratorTrait(*this, HS); OnDiskChainedHashTableGenerator Generator; SmallVector SavedStrings; unsigned NumHeaderSearchEntries = 0; for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { const FileEntry *File = FilesByUID[UID]; if (!File) continue; // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo // from the external source if it was not provided already. const HeaderFileInfo &HFI = HS.getFileInfo(File); if (HFI.External && Chain) continue; if (HFI.isModuleHeader && !HFI.isCompilingModuleHeader) continue; // Turn the file name into an absolute path, if it isn't already. const char *Filename = File->getName(); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); // If we performed any translation on the file name at all, we need to // save this string, since the generator will refer to it later. if (Filename != File->getName()) { Filename = strdup(Filename); SavedStrings.push_back(Filename); } HeaderFileInfoTrait::key_type key = { File, Filename }; Generator.insert(key, HFI, GeneratorTrait); ++NumHeaderSearchEntries; } // Create the on-disk hash table in a buffer. SmallString<4096> TableData; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(TableData); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, GeneratorTrait); } // Create a blob abbreviation using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); // Write the header search table RecordData Record; Record.push_back(HEADER_SEARCH_TABLE); Record.push_back(BucketOffset); Record.push_back(NumHeaderSearchEntries); Record.push_back(TableData.size()); TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str()); // Free all of the strings we had to duplicate. for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) free(const_cast(SavedStrings[I])); } /// \brief Writes the block containing the serialized form of the /// source manager. /// /// TODO: We should probably use an on-disk hash table (stored in a /// blob), indexed based on the file name, so that we only create /// entries for files that we actually need. In the common case (no /// errors), we probably won't have to create file entries for any of /// the files in the AST. void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, const Preprocessor &PP, StringRef isysroot) { RecordData Record; // Enter the source manager block. Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3); // Abbreviations for the various kinds of source-location entries. unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream); // Write out the source location entry table. We skip the first // entry, which is always the same dummy entry. std::vector SLocEntryOffsets; RecordData PreloadSLocs; SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1); for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { // Get this source location entry. const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); FileID FID = FileID::get(I); assert(&SourceMgr.getSLocEntry(FID) == SLoc); // Record the offset of this source-location entry. SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); // Figure out which record code to use. unsigned Code; if (SLoc->isFile()) { const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); if (Cache->OrigEntry) { Code = SM_SLOC_FILE_ENTRY; } else Code = SM_SLOC_BUFFER_ENTRY; } else Code = SM_SLOC_EXPANSION_ENTRY; Record.clear(); Record.push_back(Code); // Starting offset of this entry within this module, so skip the dummy. Record.push_back(SLoc->getOffset() - 2); if (SLoc->isFile()) { const SrcMgr::FileInfo &File = SLoc->getFile(); Record.push_back(File.getIncludeLoc().getRawEncoding()); Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding Record.push_back(File.hasLineDirectives()); const SrcMgr::ContentCache *Content = File.getContentCache(); if (Content->OrigEntry) { assert(Content->OrigEntry == Content->ContentsEntry && "Writing to AST an overridden file is not supported"); // The source location entry is a file. Emit input file ID. assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry"); Record.push_back(InputFileIDs[Content->OrigEntry]); Record.push_back(File.NumCreatedFIDs); FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID); if (FDI != FileDeclIDs.end()) { Record.push_back(FDI->second->FirstDeclIndex); Record.push_back(FDI->second->DeclIDs.size()); } else { Record.push_back(0); Record.push_back(0); } Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record); if (Content->BufferOverridden) { Record.clear(); Record.push_back(SM_SLOC_BUFFER_BLOB); const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, StringRef(Buffer->getBufferStart(), Buffer->getBufferSize() + 1)); } } else { // The source location entry is a buffer. The blob associated // with this entry contains the contents of the buffer. // We add one to the size so that we capture the trailing NULL // that is required by llvm::MemoryBuffer::getMemBuffer (on // the reader side). const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); const char *Name = Buffer->getBufferIdentifier(); Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, StringRef(Name, strlen(Name) + 1)); Record.clear(); Record.push_back(SM_SLOC_BUFFER_BLOB); Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, StringRef(Buffer->getBufferStart(), Buffer->getBufferSize() + 1)); if (strcmp(Name, "") == 0) { PreloadSLocs.push_back(SLocEntryOffsets.size()); } } } else { // The source location entry is a macro expansion. const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); Record.push_back(Expansion.getSpellingLoc().getRawEncoding()); Record.push_back(Expansion.getExpansionLocStart().getRawEncoding()); Record.push_back(Expansion.isMacroArgExpansion() ? 0 : Expansion.getExpansionLocEnd().getRawEncoding()); // Compute the token length for this macro expansion. unsigned NextOffset = SourceMgr.getNextLocalOffset(); if (I + 1 != N) NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset(); Record.push_back(NextOffset - SLoc->getOffset() - 1); Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record); } } Stream.ExitBlock(); if (SLocEntryOffsets.empty()) return; // Write the source-location offsets table into the AST block. This // table is used for lazily loading source-location information. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(SOURCE_LOCATION_OFFSETS); Record.push_back(SLocEntryOffsets.size()); Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets)); // Write the source location entry preloads array, telling the AST // reader which source locations entries it should load eagerly. Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); // Write the line table. It depends on remapping working, so it must come // after the source location offsets. if (SourceMgr.hasLineTable()) { LineTableInfo &LineTable = SourceMgr.getLineTable(); Record.clear(); // Emit the file names Record.push_back(LineTable.getNumFilenames()); for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) { // Emit the file name const char *Filename = LineTable.getFilename(I); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); unsigned FilenameLen = Filename? strlen(Filename) : 0; Record.push_back(FilenameLen); if (FilenameLen) Record.insert(Record.end(), Filename, Filename + FilenameLen); } // Emit the line entries for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); L != LEnd; ++L) { // Only emit entries for local files. if (L->first.ID < 0) continue; // Emit the file ID Record.push_back(L->first.ID); // Emit the line entries Record.push_back(L->second.size()); for (std::vector::iterator LE = L->second.begin(), LEEnd = L->second.end(); LE != LEEnd; ++LE) { Record.push_back(LE->FileOffset); Record.push_back(LE->LineNo); Record.push_back(LE->FilenameID); Record.push_back((unsigned)LE->FileKind); Record.push_back(LE->IncludeOffset); } } Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record); } } //===----------------------------------------------------------------------===// // Preprocessor Serialization //===----------------------------------------------------------------------===// namespace { class ASTMacroTableTrait { public: typedef IdentID key_type; typedef key_type key_type_ref; struct Data { uint32_t MacroDirectivesOffset; }; typedef Data data_type; typedef const data_type &data_type_ref; static unsigned ComputeHash(IdentID IdID) { return llvm::hash_value(IdID); } std::pair static EmitKeyDataLength(raw_ostream& Out, key_type_ref Key, data_type_ref Data) { unsigned KeyLen = 4; // IdentID. unsigned DataLen = 4; // MacroDirectivesOffset. return std::make_pair(KeyLen, DataLen); } static void EmitKey(raw_ostream& Out, key_type_ref Key, unsigned KeyLen) { clang::io::Emit32(Out, Key); } static void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data, unsigned) { clang::io::Emit32(Out, Data.MacroDirectivesOffset); } }; } // end anonymous namespace static int compareMacroDirectives( const std::pair *X, const std::pair *Y) { return X->first->getName().compare(Y->first->getName()); } static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule, const Preprocessor &PP) { if (MacroInfo *MI = MD->getMacroInfo()) if (MI->isBuiltinMacro()) return true; if (IsModule) { SourceLocation Loc = MD->getLocation(); if (Loc.isInvalid()) return true; if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID()) return true; } return false; } /// \brief Writes the block containing the serialized form of the /// preprocessor. /// void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); if (PPRec) WritePreprocessorDetail(*PPRec); RecordData Record; // If the preprocessor __COUNTER__ value has been bumped, remember it. if (PP.getCounterValue() != 0) { Record.push_back(PP.getCounterValue()); Stream.EmitRecord(PP_COUNTER_VALUE, Record); Record.clear(); } // Enter the preprocessor block. Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); // If the AST file contains __DATE__ or __TIME__ emit a warning about this. // FIXME: use diagnostics subsystem for localization etc. if (PP.SawDateOrTime()) fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); // Loop over all the macro directives that are live at the end of the file, // emitting each to the PP section. // Construct the list of macro directives that need to be serialized. SmallVector, 2> MacroDirectives; for (Preprocessor::macro_iterator I = PP.macro_begin(/*IncludeExternalMacros=*/false), E = PP.macro_end(/*IncludeExternalMacros=*/false); I != E; ++I) { MacroDirectives.push_back(std::make_pair(I->first, I->second)); } // Sort the set of macro definitions that need to be serialized by the // name of the macro, to provide a stable ordering. llvm::array_pod_sort(MacroDirectives.begin(), MacroDirectives.end(), &compareMacroDirectives); OnDiskChainedHashTableGenerator Generator; // Emit the macro directives as a list and associate the offset with the // identifier they belong to. for (unsigned I = 0, N = MacroDirectives.size(); I != N; ++I) { const IdentifierInfo *Name = MacroDirectives[I].first; uint64_t MacroDirectiveOffset = Stream.GetCurrentBitNo(); MacroDirective *MD = MacroDirectives[I].second; // If the macro or identifier need no updates, don't write the macro history // for this one. // FIXME: Chain the macro history instead of re-writing it. if (MD->isFromPCH() && Name->isFromAST() && !Name->hasChangedSinceDeserialization()) continue; // Emit the macro directives in reverse source order. for (; MD; MD = MD->getPrevious()) { if (MD->isHidden()) continue; if (shouldIgnoreMacro(MD, IsModule, PP)) continue; AddSourceLocation(MD->getLocation(), Record); Record.push_back(MD->getKind()); if (DefMacroDirective *DefMD = dyn_cast(MD)) { MacroID InfoID = getMacroRef(DefMD->getInfo(), Name); Record.push_back(InfoID); Record.push_back(DefMD->isImported()); Record.push_back(DefMD->isAmbiguous()); } else if (VisibilityMacroDirective * VisMD = dyn_cast(MD)) { Record.push_back(VisMD->isPublic()); } } if (Record.empty()) continue; Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record); Record.clear(); IdentMacroDirectivesOffsetMap[Name] = MacroDirectiveOffset; IdentID NameID = getIdentifierRef(Name); ASTMacroTableTrait::Data data; data.MacroDirectivesOffset = MacroDirectiveOffset; Generator.insert(NameID, data); } /// \brief Offsets of each of the macros into the bitstream, indexed by /// the local macro ID /// /// For each identifier that is associated with a macro, this map /// provides the offset into the bitstream where that macro is /// defined. std::vector MacroOffsets; for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) { const IdentifierInfo *Name = MacroInfosToEmit[I].Name; MacroInfo *MI = MacroInfosToEmit[I].MI; MacroID ID = MacroInfosToEmit[I].ID; if (ID < FirstMacroID) { assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?"); continue; } // Record the local offset of this macro. unsigned Index = ID - FirstMacroID; if (Index == MacroOffsets.size()) MacroOffsets.push_back(Stream.GetCurrentBitNo()); else { if (Index > MacroOffsets.size()) MacroOffsets.resize(Index + 1); MacroOffsets[Index] = Stream.GetCurrentBitNo(); } AddIdentifierRef(Name, Record); Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc())); AddSourceLocation(MI->getDefinitionLoc(), Record); AddSourceLocation(MI->getDefinitionEndLoc(), Record); Record.push_back(MI->isUsed()); unsigned Code; if (MI->isObjectLike()) { Code = PP_MACRO_OBJECT_LIKE; } else { Code = PP_MACRO_FUNCTION_LIKE; Record.push_back(MI->isC99Varargs()); Record.push_back(MI->isGNUVarargs()); Record.push_back(MI->hasCommaPasting()); Record.push_back(MI->getNumArgs()); for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end(); I != E; ++I) AddIdentifierRef(*I, Record); } // If we have a detailed preprocessing record, record the macro definition // ID that corresponds to this macro. if (PPRec) Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]); Stream.EmitRecord(Code, Record); Record.clear(); // Emit the tokens array. for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { // Note that we know that the preprocessor does not have any annotation // tokens in it because they are created by the parser, and thus can't // be in a macro definition. const Token &Tok = MI->getReplacementToken(TokNo); AddToken(Tok, Record); Stream.EmitRecord(PP_TOKEN, Record); Record.clear(); } ++NumMacros; } Stream.ExitBlock(); // Create the on-disk hash table in a buffer. SmallString<4096> MacroTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(MacroTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out); } // Write the macro table using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MACRO_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MacroTableAbbrev = Stream.EmitAbbrev(Abbrev); Record.push_back(MACRO_TABLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(MacroTableAbbrev, Record, MacroTable.str()); Record.clear(); // Write the offsets table for macro IDs. using namespace llvm; Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(MACRO_OFFSET); Record.push_back(MacroOffsets.size()); Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS); Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, data(MacroOffsets)); } void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { if (PPRec.local_begin() == PPRec.local_end()) return; SmallVector PreprocessedEntityOffsets; // Enter the preprocessor block. Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); // If the preprocessor has a preprocessing record, emit it. unsigned NumPreprocessingRecords = 0; using namespace llvm; // Set up the abbreviation for unsigned InclusionAbbrev = 0; { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); InclusionAbbrev = Stream.EmitAbbrev(Abbrev); } unsigned FirstPreprocessorEntityID = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) + NUM_PREDEF_PP_ENTITY_IDS; unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; RecordData Record; for (PreprocessingRecord::iterator E = PPRec.local_begin(), EEnd = PPRec.local_end(); E != EEnd; (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { Record.clear(); PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo())); if (MacroDefinition *MD = dyn_cast(*E)) { // Record this macro definition's ID. MacroDefinitions[MD] = NextPreprocessorEntityID; AddIdentifierRef(MD->getName(), Record); Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); continue; } if (MacroExpansion *ME = dyn_cast(*E)) { Record.push_back(ME->isBuiltinMacro()); if (ME->isBuiltinMacro()) AddIdentifierRef(ME->getName(), Record); else Record.push_back(MacroDefinitions[ME->getDefinition()]); Stream.EmitRecord(PPD_MACRO_EXPANSION, Record); continue; } if (InclusionDirective *ID = dyn_cast(*E)) { Record.push_back(PPD_INCLUSION_DIRECTIVE); Record.push_back(ID->getFileName().size()); Record.push_back(ID->wasInQuotes()); Record.push_back(static_cast(ID->getKind())); Record.push_back(ID->importedModule()); SmallString<64> Buffer; Buffer += ID->getFileName(); // Check that the FileEntry is not null because it was not resolved and // we create a PCH even with compiler errors. if (ID->getFile()) Buffer += ID->getFile()->getName(); Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); continue; } llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); } Stream.ExitBlock(); // Write the offsets table for the preprocessing record. if (NumPreprocessingRecords > 0) { assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords); // Write the offsets table for identifier IDs. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(PPD_ENTITIES_OFFSETS); Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS); Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, data(PreprocessedEntityOffsets)); } } unsigned ASTWriter::getSubmoduleID(Module *Mod) { llvm::DenseMap::iterator Known = SubmoduleIDs.find(Mod); if (Known != SubmoduleIDs.end()) return Known->second; return SubmoduleIDs[Mod] = NextSubmoduleID++; } unsigned ASTWriter::getExistingSubmoduleID(Module *Mod) const { if (!Mod) return 0; llvm::DenseMap::const_iterator Known = SubmoduleIDs.find(Mod); if (Known != SubmoduleIDs.end()) return Known->second; return 0; } /// \brief Compute the number of modules within the given tree (including the /// given module). static unsigned getNumberOfModules(Module *Mod) { unsigned ChildModules = 0; for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) ChildModules += getNumberOfModules(*Sub); return ChildModules + 1; } void ASTWriter::WriteSubmodules(Module *WritingModule) { // Determine the dependencies of our module and each of it's submodules. // FIXME: This feels like it belongs somewhere else, but there are no // other consumers of this information. SourceManager &SrcMgr = PP->getSourceManager(); ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); for (ASTContext::import_iterator I = Context->local_import_begin(), IEnd = Context->local_import_end(); I != IEnd; ++I) { if (Module *ImportedFrom = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(), SrcMgr))) { ImportedFrom->Imports.push_back(I->getImportedModule()); } } // Enter the submodule description block. Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); // Write the abbreviations needed for the submodules block. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev); // Write the submodule metadata block. RecordData Record; Record.push_back(getNumberOfModules(WritingModule)); Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS); Stream.EmitRecord(SUBMODULE_METADATA, Record); // Write all of the submodules. std::queue Q; Q.push(WritingModule); while (!Q.empty()) { Module *Mod = Q.front(); Q.pop(); unsigned ID = getSubmoduleID(Mod); // Emit the definition of the block. Record.clear(); Record.push_back(SUBMODULE_DEFINITION); Record.push_back(ID); if (Mod->Parent) { assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); Record.push_back(SubmoduleIDs[Mod->Parent]); } else { Record.push_back(0); } Record.push_back(Mod->IsFramework); Record.push_back(Mod->IsExplicit); Record.push_back(Mod->IsSystem); Record.push_back(Mod->InferSubmodules); Record.push_back(Mod->InferExplicitSubmodules); Record.push_back(Mod->InferExportWildcard); Record.push_back(Mod->ConfigMacrosExhaustive); Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); // Emit the requirements. for (unsigned I = 0, N = Mod->Requirements.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_REQUIRES); Record.push_back(Mod->Requirements[I].second); Stream.EmitRecordWithBlob(RequiresAbbrev, Record, Mod->Requirements[I].first); } // Emit the umbrella header, if there is one. if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) { Record.clear(); Record.push_back(SUBMODULE_UMBRELLA_HEADER); Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, UmbrellaHeader->getName()); } else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) { Record.clear(); Record.push_back(SUBMODULE_UMBRELLA_DIR); Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, UmbrellaDir->getName()); } // Emit the headers. for (unsigned I = 0, N = Mod->NormalHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_HEADER); Stream.EmitRecordWithBlob(HeaderAbbrev, Record, Mod->NormalHeaders[I]->getName()); } // Emit the excluded headers. for (unsigned I = 0, N = Mod->ExcludedHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_EXCLUDED_HEADER); Stream.EmitRecordWithBlob(ExcludedHeaderAbbrev, Record, Mod->ExcludedHeaders[I]->getName()); } // Emit the private headers. for (unsigned I = 0, N = Mod->PrivateHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_PRIVATE_HEADER); Stream.EmitRecordWithBlob(PrivateHeaderAbbrev, Record, Mod->PrivateHeaders[I]->getName()); } ArrayRef TopHeaders = Mod->getTopHeaders(PP->getFileManager()); for (unsigned I = 0, N = TopHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_TOPHEADER); Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, TopHeaders[I]->getName()); } // Emit the imports. if (!Mod->Imports.empty()) { Record.clear(); for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { unsigned ImportedID = getSubmoduleID(Mod->Imports[I]); assert(ImportedID && "Unknown submodule!"); Record.push_back(ImportedID); } Stream.EmitRecord(SUBMODULE_IMPORTS, Record); } // Emit the exports. if (!Mod->Exports.empty()) { Record.clear(); for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { if (Module *Exported = Mod->Exports[I].getPointer()) { unsigned ExportedID = SubmoduleIDs[Exported]; assert(ExportedID > 0 && "Unknown submodule ID?"); Record.push_back(ExportedID); } else { Record.push_back(0); } Record.push_back(Mod->Exports[I].getInt()); } Stream.EmitRecord(SUBMODULE_EXPORTS, Record); } //FIXME: How do we emit the 'use'd modules? They may not be submodules. // Might be unnecessary as use declarations are only used to build the // module itself. // Emit the link libraries. for (unsigned I = 0, N = Mod->LinkLibraries.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_LINK_LIBRARY); Record.push_back(Mod->LinkLibraries[I].IsFramework); Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, Mod->LinkLibraries[I].Library); } // Emit the conflicts. for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_CONFLICT); unsigned OtherID = getSubmoduleID(Mod->Conflicts[I].Other); assert(OtherID && "Unknown submodule!"); Record.push_back(OtherID); Stream.EmitRecordWithBlob(ConflictAbbrev, Record, Mod->Conflicts[I].Message); } // Emit the configuration macros. for (unsigned I = 0, N = Mod->ConfigMacros.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_CONFIG_MACRO); Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, Mod->ConfigMacros[I]); } // Queue up the submodules of this module. for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) Q.push(*Sub); } Stream.ExitBlock(); assert((NextSubmoduleID - FirstSubmoduleID == getNumberOfModules(WritingModule)) && "Wrong # of submodules"); } serialization::SubmoduleID ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) { if (Loc.isInvalid() || !WritingModule) return 0; // No submodule // Find the module that owns this location. ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); Module *OwningMod = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager())); if (!OwningMod) return 0; // Check whether this submodule is part of our own module. if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule)) return 0; return getSubmoduleID(OwningMod); } void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag, bool isModule) { // Make sure set diagnostic pragmas don't affect the translation unit that // imports the module. // FIXME: Make diagnostic pragma sections work properly with modules. if (isModule) return; llvm::SmallDenseMap DiagStateIDMap; unsigned CurrID = 0; DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one. RecordData Record; for (DiagnosticsEngine::DiagStatePointsTy::const_iterator I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end(); I != E; ++I) { const DiagnosticsEngine::DiagStatePoint &point = *I; if (point.Loc.isInvalid()) continue; Record.push_back(point.Loc.getRawEncoding()); unsigned &DiagStateID = DiagStateIDMap[point.State]; Record.push_back(DiagStateID); if (DiagStateID == 0) { DiagStateID = ++CurrID; for (DiagnosticsEngine::DiagState::const_iterator I = point.State->begin(), E = point.State->end(); I != E; ++I) { if (I->second.isPragma()) { Record.push_back(I->first); Record.push_back(I->second.getMapping()); } } Record.push_back(-1); // mark the end of the diag/map pairs for this // location. } } if (!Record.empty()) Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); } void ASTWriter::WriteCXXBaseSpecifiersOffsets() { if (CXXBaseSpecifiersOffsets.empty()) return; RecordData Record; // Create a blob abbreviation for the C++ base specifiers offsets. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); // Write the base specifier offsets table. Record.clear(); Record.push_back(CXX_BASE_SPECIFIER_OFFSETS); Record.push_back(CXXBaseSpecifiersOffsets.size()); Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record, data(CXXBaseSpecifiersOffsets)); } //===----------------------------------------------------------------------===// // Type Serialization //===----------------------------------------------------------------------===// /// \brief Write the representation of a type to the AST stream. void ASTWriter::WriteType(QualType T) { TypeIdx &Idx = TypeIdxs[T]; if (Idx.getIndex() == 0) // we haven't seen this type before. Idx = TypeIdx(NextTypeID++); assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); // Record the offset for this type. unsigned Index = Idx.getIndex() - FirstTypeID; if (TypeOffsets.size() == Index) TypeOffsets.push_back(Stream.GetCurrentBitNo()); else if (TypeOffsets.size() < Index) { TypeOffsets.resize(Index + 1); TypeOffsets[Index] = Stream.GetCurrentBitNo(); } RecordData Record; // Emit the type's representation. ASTTypeWriter W(*this, Record); if (T.hasLocalNonFastQualifiers()) { Qualifiers Qs = T.getLocalQualifiers(); AddTypeRef(T.getLocalUnqualifiedType(), Record); Record.push_back(Qs.getAsOpaqueValue()); W.Code = TYPE_EXT_QUAL; } else { switch (T->getTypeClass()) { // For all of the concrete, non-dependent types, call the // appropriate visitor function. #define TYPE(Class, Base) \ case Type::Class: W.Visit##Class##Type(cast(T)); break; #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" } } // Emit the serialized record. Stream.EmitRecord(W.Code, Record); // Flush any expressions that were written as part of this type. FlushStmts(); } //===----------------------------------------------------------------------===// // Declaration Serialization //===----------------------------------------------------------------------===// /// \brief Write the block containing all of the declaration IDs /// lexically declared within the given DeclContext. /// /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the /// bistream, or 0 if no block was written. uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, DeclContext *DC) { if (DC->decls_empty()) return 0; uint64_t Offset = Stream.GetCurrentBitNo(); RecordData Record; Record.push_back(DECL_CONTEXT_LEXICAL); SmallVector Decls; for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end(); D != DEnd; ++D) Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D))); ++NumLexicalDeclContexts; Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls)); return Offset; } void ASTWriter::WriteTypeDeclOffsets() { using namespace llvm; RecordData Record; // Write the type offsets array BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(TYPE_OFFSET); Record.push_back(TypeOffsets.size()); Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS); Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets)); // Write the declaration offsets array Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(DECL_OFFSET); Record.push_back(DeclOffsets.size()); Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS); Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets)); } void ASTWriter::WriteFileDeclIDsMap() { using namespace llvm; RecordData Record; // Join the vectors of DeclIDs from all files. SmallVector FileSortedIDs; for (FileDeclIDsTy::iterator FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) { DeclIDInFileInfo &Info = *FI->second; Info.FirstDeclIndex = FileSortedIDs.size(); for (LocDeclIDsTy::iterator DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI) FileSortedIDs.push_back(DI->second); } BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); Record.push_back(FILE_SORTED_DECLS); Record.push_back(FileSortedIDs.size()); Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs)); } void ASTWriter::WriteComments() { Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3); ArrayRef RawComments = Context->Comments.getComments(); RecordData Record; for (ArrayRef::iterator I = RawComments.begin(), E = RawComments.end(); I != E; ++I) { Record.clear(); AddSourceRange((*I)->getSourceRange(), Record); Record.push_back((*I)->getKind()); Record.push_back((*I)->isTrailingComment()); Record.push_back((*I)->isAlmostTrailingComment()); Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record); } Stream.ExitBlock(); } //===----------------------------------------------------------------------===// // Global Method Pool and Selector Serialization //===----------------------------------------------------------------------===// namespace { // Trait used for the on-disk hash table used in the method pool. class ASTMethodPoolTrait { ASTWriter &Writer; public: typedef Selector key_type; typedef key_type key_type_ref; struct data_type { SelectorID ID; ObjCMethodList Instance, Factory; }; typedef const data_type& data_type_ref; explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } static unsigned ComputeHash(Selector Sel) { return serialization::ComputeHash(Sel); } std::pair EmitKeyDataLength(raw_ostream& Out, Selector Sel, data_type_ref Methods) { unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); clang::io::Emit16(Out, KeyLen); unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) DataLen += 4; for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) DataLen += 4; clang::io::Emit16(Out, DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, Selector Sel, unsigned) { uint64_t Start = Out.tell(); assert((Start >> 32) == 0 && "Selector key offset too large"); Writer.SetSelectorOffset(Sel, Start); unsigned N = Sel.getNumArgs(); clang::io::Emit16(Out, N); if (N == 0) N = 1; for (unsigned I = 0; I != N; ++I) clang::io::Emit32(Out, Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); } void EmitData(raw_ostream& Out, key_type_ref, data_type_ref Methods, unsigned DataLen) { uint64_t Start = Out.tell(); (void)Start; clang::io::Emit32(Out, Methods.ID); unsigned NumInstanceMethods = 0; for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) ++NumInstanceMethods; unsigned NumFactoryMethods = 0; for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) ++NumFactoryMethods; unsigned InstanceBits = Methods.Instance.getBits(); assert(InstanceBits < 4); unsigned NumInstanceMethodsAndBits = (NumInstanceMethods << 2) | InstanceBits; unsigned FactoryBits = Methods.Factory.getBits(); assert(FactoryBits < 4); unsigned NumFactoryMethodsAndBits = (NumFactoryMethods << 2) | FactoryBits; clang::io::Emit16(Out, NumInstanceMethodsAndBits); clang::io::Emit16(Out, NumFactoryMethodsAndBits); for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); assert(Out.tell() - Start == DataLen && "Data length is wrong"); } }; } // end anonymous namespace /// \brief Write ObjC data: selectors and the method pool. /// /// The method pool contains both instance and factory methods, stored /// in an on-disk hash table indexed by the selector. The hash table also /// contains an empty entry for every other selector known to Sema. void ASTWriter::WriteSelectors(Sema &SemaRef) { using namespace llvm; // Do we have to do anything at all? if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) return; unsigned NumTableEntries = 0; // Create and write out the blob that contains selectors and the method pool. { OnDiskChainedHashTableGenerator Generator; ASTMethodPoolTrait Trait(*this); // Create the on-disk hash table representation. We walk through every // selector we've seen and look it up in the method pool. SelectorOffsets.resize(NextSelectorID - FirstSelectorID); for (llvm::DenseMap::iterator I = SelectorIDs.begin(), E = SelectorIDs.end(); I != E; ++I) { Selector S = I->first; Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); ASTMethodPoolTrait::data_type Data = { I->second, ObjCMethodList(), ObjCMethodList() }; if (F != SemaRef.MethodPool.end()) { Data.Instance = F->second.first; Data.Factory = F->second.second; } // Only write this selector if it's not in an existing AST or something // changed. if (Chain && I->second < FirstSelectorID) { // Selector already exists. Did it change? bool changed = false; for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method; M = M->getNext()) { if (!M->Method->isFromASTFile()) changed = true; } for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method; M = M->getNext()) { if (!M->Method->isFromASTFile()) changed = true; } if (!changed) continue; } else if (Data.Instance.Method || Data.Factory.Method) { // A new method pool entry. ++NumTableEntries; } Generator.insert(S, Data, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> MethodPool; uint32_t BucketOffset; { ASTMethodPoolTrait Trait(*this); llvm::raw_svector_ostream Out(MethodPool); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Create a blob abbreviation BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); // Write the method pool RecordData Record; Record.push_back(METHOD_POOL); Record.push_back(BucketOffset); Record.push_back(NumTableEntries); Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str()); // Create a blob abbreviation for the selector table offsets. Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); // Write the selector offsets table. Record.clear(); Record.push_back(SELECTOR_OFFSETS); Record.push_back(SelectorOffsets.size()); Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS); Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, data(SelectorOffsets)); } } /// \brief Write the selectors referenced in @@selector expression into AST file. void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { using namespace llvm; if (SemaRef.ReferencedSelectors.empty()) return; RecordData Record; // Note: this writes out all references even for a dependent AST. But it is // very tricky to fix, and given that @@selector shouldn't really appear in // headers, probably not worth it. It's not a correctness issue. for (DenseMap::iterator S = SemaRef.ReferencedSelectors.begin(), E = SemaRef.ReferencedSelectors.end(); S != E; ++S) { Selector Sel = (*S).first; SourceLocation Loc = (*S).second; AddSelectorRef(Sel, Record); AddSourceLocation(Loc, Record); } Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record); } //===----------------------------------------------------------------------===// // Identifier Table Serialization //===----------------------------------------------------------------------===// namespace { class ASTIdentifierTableTrait { ASTWriter &Writer; Preprocessor &PP; IdentifierResolver &IdResolver; bool IsModule; /// \brief Determines whether this is an "interesting" identifier /// that needs a full IdentifierInfo structure written into the hash /// table. bool isInterestingIdentifier(IdentifierInfo *II, MacroDirective *&Macro) { if (II->isPoisoned() || II->isExtensionToken() || II->getObjCOrBuiltinID() || II->hasRevertedTokenIDToIdentifier() || II->getFETokenInfo()) return true; return hadMacroDefinition(II, Macro); } bool hadMacroDefinition(IdentifierInfo *II, MacroDirective *&Macro) { if (!II->hadMacroDefinition()) return false; if (Macro || (Macro = PP.getMacroDirectiveHistory(II))) { if (!IsModule) return !shouldIgnoreMacro(Macro, IsModule, PP); SubmoduleID ModID; if (getFirstPublicSubmoduleMacro(Macro, ModID)) return true; } return false; } DefMacroDirective *getFirstPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID) { ModID = 0; if (DefMacroDirective *DefMD = getPublicSubmoduleMacro(MD, ModID)) if (!shouldIgnoreMacro(DefMD, IsModule, PP)) return DefMD; return 0; } DefMacroDirective *getNextPublicSubmoduleMacro(DefMacroDirective *MD, SubmoduleID &ModID) { if (DefMacroDirective * DefMD = getPublicSubmoduleMacro(MD->getPrevious(), ModID)) if (!shouldIgnoreMacro(DefMD, IsModule, PP)) return DefMD; return 0; } /// \brief Traverses the macro directives history and returns the latest /// macro that is public and not undefined in the same submodule. /// A macro that is defined in submodule A and undefined in submodule B, /// will still be considered as defined/exported from submodule A. DefMacroDirective *getPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID) { if (!MD) return 0; SubmoduleID OrigModID = ModID; bool isUndefined = false; Optional isPublic; for (; MD; MD = MD->getPrevious()) { if (MD->isHidden()) continue; SubmoduleID ThisModID = getSubmoduleID(MD); if (ThisModID == 0) { isUndefined = false; isPublic = Optional(); continue; } if (ThisModID != ModID){ ModID = ThisModID; isUndefined = false; isPublic = Optional(); } // We are looking for a definition in a different submodule than the one // that we started with. If a submodule has re-definitions of the same // macro, only the last definition will be used as the "exported" one. if (ModID == OrigModID) continue; if (DefMacroDirective *DefMD = dyn_cast(MD)) { if (!isUndefined && (!isPublic.hasValue() || isPublic.getValue())) return DefMD; continue; } if (isa(MD)) { isUndefined = true; continue; } VisibilityMacroDirective *VisMD = cast(MD); if (!isPublic.hasValue()) isPublic = VisMD->isPublic(); } return 0; } SubmoduleID getSubmoduleID(MacroDirective *MD) { if (DefMacroDirective *DefMD = dyn_cast(MD)) { MacroInfo *MI = DefMD->getInfo(); if (unsigned ID = MI->getOwningModuleID()) return ID; return Writer.inferSubmoduleIDFromLocation(MI->getDefinitionLoc()); } return Writer.inferSubmoduleIDFromLocation(MD->getLocation()); } public: typedef IdentifierInfo* key_type; typedef key_type key_type_ref; typedef IdentID data_type; typedef data_type data_type_ref; ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, IdentifierResolver &IdResolver, bool IsModule) : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { } static unsigned ComputeHash(const IdentifierInfo* II) { return llvm::HashString(II->getName()); } std::pair EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { unsigned KeyLen = II->getLength() + 1; unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 MacroDirective *Macro = 0; if (isInterestingIdentifier(II, Macro)) { DataLen += 2; // 2 bytes for builtin ID DataLen += 2; // 2 bytes for flags if (hadMacroDefinition(II, Macro)) { DataLen += 4; // MacroDirectives offset. if (IsModule) { SubmoduleID ModID; for (DefMacroDirective * DefMD = getFirstPublicSubmoduleMacro(Macro, ModID); DefMD; DefMD = getNextPublicSubmoduleMacro(DefMD, ModID)) { DataLen += 4; // MacroInfo ID. } DataLen += 4; } } for (IdentifierResolver::iterator D = IdResolver.begin(II), DEnd = IdResolver.end(); D != DEnd; ++D) DataLen += sizeof(DeclID); } clang::io::Emit16(Out, DataLen); // We emit the key length after the data length so that every // string is preceded by a 16-bit length. This matches the PTH // format for storing identifiers. clang::io::Emit16(Out, KeyLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, const IdentifierInfo* II, unsigned KeyLen) { // Record the location of the key data. This is used when generating // the mapping from persistent IDs to strings. Writer.SetIdentifierOffset(II, Out.tell()); Out.write(II->getNameStart(), KeyLen); } void EmitData(raw_ostream& Out, IdentifierInfo* II, IdentID ID, unsigned) { MacroDirective *Macro = 0; if (!isInterestingIdentifier(II, Macro)) { clang::io::Emit32(Out, ID << 1); return; } clang::io::Emit32(Out, (ID << 1) | 0x01); uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID(); assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader."); clang::io::Emit16(Out, Bits); Bits = 0; bool HadMacroDefinition = hadMacroDefinition(II, Macro); Bits = (Bits << 1) | unsigned(HadMacroDefinition); Bits = (Bits << 1) | unsigned(IsModule); Bits = (Bits << 1) | unsigned(II->isExtensionToken()); Bits = (Bits << 1) | unsigned(II->isPoisoned()); Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); clang::io::Emit16(Out, Bits); if (HadMacroDefinition) { clang::io::Emit32(Out, Writer.getMacroDirectivesOffset(II)); if (IsModule) { // Write the IDs of macros coming from different submodules. SubmoduleID ModID; for (DefMacroDirective * DefMD = getFirstPublicSubmoduleMacro(Macro, ModID); DefMD; DefMD = getNextPublicSubmoduleMacro(DefMD, ModID)) { MacroID InfoID = Writer.getMacroID(DefMD->getInfo()); assert(InfoID); clang::io::Emit32(Out, InfoID); } clang::io::Emit32(Out, 0); } } // Emit the declaration IDs in reverse order, because the // IdentifierResolver provides the declarations as they would be // visible (e.g., the function "stat" would come before the struct // "stat"), but the ASTReader adds declarations to the end of the list // (so we need to see the struct "status" before the function "status"). // Only emit declarations that aren't from a chained PCH, though. SmallVector Decls(IdResolver.begin(II), IdResolver.end()); for (SmallVectorImpl::reverse_iterator D = Decls.rbegin(), DEnd = Decls.rend(); D != DEnd; ++D) clang::io::Emit32(Out, Writer.getDeclID(getMostRecentLocalDecl(*D))); } /// \brief Returns the most recent local decl or the given decl if there are /// no local ones. The given decl is assumed to be the most recent one. Decl *getMostRecentLocalDecl(Decl *Orig) { // The only way a "from AST file" decl would be more recent from a local one // is if it came from a module. if (!PP.getLangOpts().Modules) return Orig; // Look for a local in the decl chain. for (Decl *D = Orig; D; D = D->getPreviousDecl()) { if (!D->isFromASTFile()) return D; // If we come up a decl from a (chained-)PCH stop since we won't find a // local one. if (D->getOwningModuleID() == 0) break; } return Orig; } }; } // end anonymous namespace /// \brief Write the identifier table into the AST file. /// /// The identifier table consists of a blob containing string data /// (the actual identifiers themselves) and a separate "offsets" index /// that maps identifier IDs to locations within the blob. void ASTWriter::WriteIdentifierTable(Preprocessor &PP, IdentifierResolver &IdResolver, bool IsModule) { using namespace llvm; // Create and write out the blob that contains the identifier // strings. { OnDiskChainedHashTableGenerator Generator; ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); // Look for any identifiers that were named while processing the // headers, but are otherwise not needed. We add these to the hash // table to enable checking of the predefines buffer in the case // where the user adds new macro definitions when building the AST // file. for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) getIdentifierRef(ID->second); // Create the on-disk hash table representation. We only store offsets // for identifiers that appear here for the first time. IdentifierOffsets.resize(NextIdentID - FirstIdentID); for (llvm::DenseMap::iterator ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); ID != IDEnd; ++ID) { assert(ID->first && "NULL identifier in identifier table"); if (!Chain || !ID->first->isFromAST() || ID->first->hasChangedSinceDeserialization()) Generator.insert(const_cast(ID->first), ID->second, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> IdentifierTable; uint32_t BucketOffset; { ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); llvm::raw_svector_ostream Out(IdentifierTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Create a blob abbreviation BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); // Write the identifier table RecordData Record; Record.push_back(IDENTIFIER_TABLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str()); } // Write the offsets table for identifier IDs. BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); #ifndef NDEBUG for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I) assert(IdentifierOffsets[I] && "Missing identifier offset?"); #endif RecordData Record; Record.push_back(IDENTIFIER_OFFSET); Record.push_back(IdentifierOffsets.size()); Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS); Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, data(IdentifierOffsets)); } //===----------------------------------------------------------------------===// // DeclContext's Name Lookup Table Serialization //===----------------------------------------------------------------------===// namespace { // Trait used for the on-disk hash table used in the method pool. class ASTDeclContextNameLookupTrait { ASTWriter &Writer; public: typedef DeclarationName key_type; typedef key_type key_type_ref; typedef DeclContext::lookup_result data_type; typedef const data_type& data_type_ref; explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { } unsigned ComputeHash(DeclarationName Name) { llvm::FoldingSetNodeID ID; ID.AddInteger(Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: ID.AddString(Name.getAsIdentifierInfo()->getName()); break; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector())); break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: break; case DeclarationName::CXXOperatorName: ID.AddInteger(Name.getCXXOverloadedOperator()); break; case DeclarationName::CXXLiteralOperatorName: ID.AddString(Name.getCXXLiteralIdentifier()->getName()); case DeclarationName::CXXUsingDirective: break; } return ID.ComputeHash(); } std::pair EmitKeyDataLength(raw_ostream& Out, DeclarationName Name, data_type_ref Lookup) { unsigned KeyLen = 1; switch (Name.getNameKind()) { case DeclarationName::Identifier: case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: case DeclarationName::CXXLiteralOperatorName: KeyLen += 4; break; case DeclarationName::CXXOperatorName: KeyLen += 1; break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: case DeclarationName::CXXUsingDirective: break; } clang::io::Emit16(Out, KeyLen); // 2 bytes for num of decls and 4 for each DeclID. unsigned DataLen = 2 + 4 * Lookup.size(); clang::io::Emit16(Out, DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) { using namespace clang::io; Emit8(Out, Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo())); return; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector())); return; case DeclarationName::CXXOperatorName: assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS && "Invalid operator?"); Emit8(Out, Name.getCXXOverloadedOperator()); return; case DeclarationName::CXXLiteralOperatorName: Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); return; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: case DeclarationName::CXXUsingDirective: return; } llvm_unreachable("Invalid name kind?"); } void EmitData(raw_ostream& Out, key_type_ref, data_type Lookup, unsigned DataLen) { uint64_t Start = Out.tell(); (void)Start; clang::io::Emit16(Out, Lookup.size()); for (DeclContext::lookup_iterator I = Lookup.begin(), E = Lookup.end(); I != E; ++I) clang::io::Emit32(Out, Writer.GetDeclRef(*I)); assert(Out.tell() - Start == DataLen && "Data length is wrong"); } }; } // end anonymous namespace /// \brief Write the block containing all of the declaration IDs /// visible from the given DeclContext. /// /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the /// bitstream, or 0 if no block was written. uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC) { if (DC->getPrimaryContext() != DC) return 0; // Since there is no name lookup into functions or methods, don't bother to // build a visible-declarations table for these entities. if (DC->isFunctionOrMethod()) return 0; // If not in C++, we perform name lookup for the translation unit via the // IdentifierInfo chains, don't bother to build a visible-declarations table. if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus) return 0; // Serialize the contents of the mapping used for lookup. Note that, // although we have two very different code paths, the serialized // representation is the same for both cases: a declaration name, // followed by a size, followed by references to the visible // declarations that have that name. uint64_t Offset = Stream.GetCurrentBitNo(); StoredDeclsMap *Map = DC->buildLookup(); if (!Map || Map->empty()) return 0; OnDiskChainedHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // Create the on-disk hash table representation. DeclarationName ConversionName; SmallVector ConversionDecls; for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); D != DEnd; ++D) { DeclarationName Name = D->first; DeclContext::lookup_result Result = D->second.getLookupResult(); if (!Result.empty()) { if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { // Hash all conversion function names to the same name. The actual // type information in conversion function name is not used in the // key (since such type information is not stable across different // modules), so the intended effect is to coalesce all of the conversion // functions under a single key. if (!ConversionName) ConversionName = Name; ConversionDecls.append(Result.begin(), Result.end()); continue; } Generator.insert(Name, Result, Trait); } } // Add the conversion functions if (!ConversionDecls.empty()) { Generator.insert(ConversionName, DeclContext::lookup_result(ConversionDecls.begin(), ConversionDecls.end()), Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> LookupTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(LookupTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Write the lookup table RecordData Record; Record.push_back(DECL_CONTEXT_VISIBLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, LookupTable.str()); Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record); ++NumVisibleDeclContexts; return Offset; } /// \brief Write an UPDATE_VISIBLE block for the given context. /// /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing /// DeclContext in a dependent AST file. As such, they only exist for the TU /// (in C++), for namespaces, and for classes with forward-declared unscoped /// enumeration members (in C++11). void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { StoredDeclsMap *Map = static_cast(DC->getLookupPtr()); if (!Map || Map->empty()) return; OnDiskChainedHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // Create the hash table. for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); D != DEnd; ++D) { DeclarationName Name = D->first; DeclContext::lookup_result Result = D->second.getLookupResult(); // For any name that appears in this table, the results are complete, i.e. // they overwrite results from previous PCHs. Merging is always a mess. if (!Result.empty()) Generator.insert(Name, Result, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> LookupTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(LookupTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Write the lookup table RecordData Record; Record.push_back(UPDATE_VISIBLE); Record.push_back(getDeclID(cast(DC))); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str()); } /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { RecordData Record; Record.push_back(Opts.fp_contract); Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); } /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { if (!SemaRef.Context.getLangOpts().OpenCL) return; const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); RecordData Record; #define OPENCLEXT(nm) Record.push_back(Opts.nm); #include "clang/Basic/OpenCLExtensions.def" Stream.EmitRecord(OPENCL_EXTENSIONS, Record); } void ASTWriter::WriteRedeclarations() { RecordData LocalRedeclChains; SmallVector LocalRedeclsMap; for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) { Decl *First = Redeclarations[I]; assert(First->isFirstDecl() && "Not the first declaration?"); Decl *MostRecent = First->getMostRecentDecl(); // If we only have a single declaration, there is no point in storing // a redeclaration chain. if (First == MostRecent) continue; unsigned Offset = LocalRedeclChains.size(); unsigned Size = 0; LocalRedeclChains.push_back(0); // Placeholder for the size. // Collect the set of local redeclarations of this declaration. for (Decl *Prev = MostRecent; Prev != First; Prev = Prev->getPreviousDecl()) { if (!Prev->isFromASTFile()) { AddDeclRef(Prev, LocalRedeclChains); ++Size; } } if (!First->isFromASTFile() && Chain) { Decl *FirstFromAST = MostRecent; for (Decl *Prev = MostRecent; Prev; Prev = Prev->getPreviousDecl()) { if (Prev->isFromASTFile()) FirstFromAST = Prev; } Chain->MergedDecls[FirstFromAST].push_back(getDeclID(First)); } LocalRedeclChains[Offset] = Size; // Reverse the set of local redeclarations, so that we store them in // order (since we found them in reverse order). std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end()); // Add the mapping from the first ID from the AST to the set of local // declarations. LocalRedeclarationsInfo Info = { getDeclID(First), Offset }; LocalRedeclsMap.push_back(Info); assert(N == Redeclarations.size() && "Deserialized a declaration we shouldn't have"); } if (LocalRedeclChains.empty()) return; // Sort the local redeclarations map by the first declaration ID, // since the reader will be performing binary searches on this information. llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end()); // Emit the local redeclarations map. using namespace llvm; llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(LOCAL_REDECLARATIONS_MAP); Record.push_back(LocalRedeclsMap.size()); Stream.EmitRecordWithBlob(AbbrevID, Record, reinterpret_cast(LocalRedeclsMap.data()), LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo)); // Emit the redeclaration chains. Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains); } void ASTWriter::WriteObjCCategories() { SmallVector CategoriesMap; RecordData Categories; for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) { unsigned Size = 0; unsigned StartIndex = Categories.size(); ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I]; // Allocate space for the size. Categories.push_back(0); // Add the categories. for (ObjCInterfaceDecl::known_categories_iterator Cat = Class->known_categories_begin(), CatEnd = Class->known_categories_end(); Cat != CatEnd; ++Cat, ++Size) { assert(getDeclID(*Cat) != 0 && "Bogus category"); AddDeclRef(*Cat, Categories); } // Update the size. Categories[StartIndex] = Size; // Record this interface -> category map. ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex }; CategoriesMap.push_back(CatInfo); } // Sort the categories map by the definition ID, since the reader will be // performing binary searches on this information. llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end()); // Emit the categories map. using namespace llvm; llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(OBJC_CATEGORIES_MAP); Record.push_back(CategoriesMap.size()); Stream.EmitRecordWithBlob(AbbrevID, Record, reinterpret_cast(CategoriesMap.data()), CategoriesMap.size() * sizeof(ObjCCategoriesInfo)); // Emit the category lists. Stream.EmitRecord(OBJC_CATEGORIES, Categories); } void ASTWriter::WriteMergedDecls() { if (!Chain || Chain->MergedDecls.empty()) return; RecordData Record; for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(), IEnd = Chain->MergedDecls.end(); I != IEnd; ++I) { DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID() : getDeclID(I->first); assert(CanonID && "Merged declaration not known?"); Record.push_back(CanonID); Record.push_back(I->second.size()); Record.append(I->second.begin(), I->second.end()); } Stream.EmitRecord(MERGED_DECLARATIONS, Record); } void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) { Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap; if (LPTMap.empty()) return; RecordData Record; for (Sema::LateParsedTemplateMapT::iterator It = LPTMap.begin(), ItEnd = LPTMap.end(); It != ItEnd; ++It) { LateParsedTemplate *LPT = It->second; AddDeclRef(It->first, Record); AddDeclRef(LPT->D, Record); Record.push_back(LPT->Toks.size()); for (CachedTokens::iterator TokIt = LPT->Toks.begin(), TokEnd = LPT->Toks.end(); TokIt != TokEnd; ++TokIt) { AddToken(*TokIt, Record); } } Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record); } //===----------------------------------------------------------------------===// // General Serialization Routines //===----------------------------------------------------------------------===// /// \brief Write a record containing the given attributes. void ASTWriter::WriteAttributes(ArrayRef Attrs, RecordDataImpl &Record) { Record.push_back(Attrs.size()); for (ArrayRef::iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){ const Attr *A = *i; Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs AddSourceRange(A->getRange(), Record); #include "clang/Serialization/AttrPCHWrite.inc" } } void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) { AddSourceLocation(Tok.getLocation(), Record); Record.push_back(Tok.getLength()); // FIXME: When reading literal tokens, reconstruct the literal pointer // if it is needed. AddIdentifierRef(Tok.getIdentifierInfo(), Record); // FIXME: Should translate token kind to a stable encoding. Record.push_back(Tok.getKind()); // FIXME: Should translate token flags to a stable encoding. Record.push_back(Tok.getFlags()); } void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { Record.push_back(Str.size()); Record.insert(Record.end(), Str.begin(), Str.end()); } void ASTWriter::AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record) { Record.push_back(Version.getMajor()); if (Optional Minor = Version.getMinor()) Record.push_back(*Minor + 1); else Record.push_back(0); if (Optional Subminor = Version.getSubminor()) Record.push_back(*Subminor + 1); else Record.push_back(0); } /// \brief Note that the identifier II occurs at the given offset /// within the identifier table. void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { IdentID ID = IdentifierIDs[II]; // Only store offsets new to this AST file. Other identifier names are looked // up earlier in the chain and thus don't need an offset. if (ID >= FirstIdentID) IdentifierOffsets[ID - FirstIdentID] = Offset; } /// \brief Note that the selector Sel occurs at the given offset /// within the method pool/selector table. void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { unsigned ID = SelectorIDs[Sel]; assert(ID && "Unknown selector"); // Don't record offsets for selectors that are also available in a different // file. if (ID < FirstSelectorID) return; SelectorOffsets[ID - FirstSelectorID] = Offset; } ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) : Stream(Stream), Context(0), PP(0), Chain(0), WritingModule(0), WritingAST(false), DoneWritingDeclsAndTypes(false), ASTHasCompilerErrors(false), FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID), FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), NextSubmoduleID(FirstSubmoduleID), FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), NumVisibleDeclContexts(0), NextCXXBaseSpecifiersID(1), DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0), DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0), DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0), DeclRecordAbbrev(0), IntegerLiteralAbbrev(0), DeclTypedefAbbrev(0), DeclVarAbbrev(0), DeclFieldAbbrev(0), DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0) { } ASTWriter::~ASTWriter() { for (FileDeclIDsTy::iterator I = FileDeclIDs.begin(), E = FileDeclIDs.end(); I != E; ++I) delete I->second; } void ASTWriter::WriteAST(Sema &SemaRef, const std::string &OutputFile, Module *WritingModule, StringRef isysroot, bool hasErrors) { WritingAST = true; ASTHasCompilerErrors = hasErrors; // Emit the file header. Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'P', 8); Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'H', 8); WriteBlockInfoBlock(); Context = &SemaRef.Context; PP = &SemaRef.PP; this->WritingModule = WritingModule; WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule); Context = 0; PP = 0; this->WritingModule = 0; WritingAST = false; } template static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, ASTWriter::RecordData &Record) { for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end(); I != E; ++I) { Writer.AddDeclRef(*I, Record); } } void ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, const std::string &OutputFile, Module *WritingModule) { using namespace llvm; bool isModule = WritingModule != 0; // Make sure that the AST reader knows to finalize itself. if (Chain) Chain->finalizeForWriting(); ASTContext &Context = SemaRef.Context; Preprocessor &PP = SemaRef.PP; // Set up predefined declaration IDs. DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID; if (Context.ObjCIdDecl) DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID; if (Context.ObjCSelDecl) DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID; if (Context.ObjCClassDecl) DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID; if (Context.ObjCProtocolClassDecl) DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID; if (Context.Int128Decl) DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID; if (Context.UInt128Decl) DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID; if (Context.ObjCInstanceTypeDecl) DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID; if (Context.BuiltinVaListDecl) DeclIDs[Context.getBuiltinVaListDecl()] = PREDEF_DECL_BUILTIN_VA_LIST_ID; if (!Chain) { // Make sure that we emit IdentifierInfos (and any attached // declarations) for builtins. We don't need to do this when we're // emitting chained PCH files, because all of the builtins will be // in the original PCH file. // FIXME: Modules won't like this at all. IdentifierTable &Table = PP.getIdentifierTable(); SmallVector BuiltinNames; if (!Context.getLangOpts().NoBuiltin) { Context.BuiltinInfo.GetBuiltinNames(BuiltinNames); } for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) getIdentifierRef(&Table.get(BuiltinNames[I])); } // If there are any out-of-date identifiers, bring them up to date. if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) { // Find out-of-date identifiers. SmallVector OutOfDate; for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) { if (ID->second->isOutOfDate()) OutOfDate.push_back(ID->second); } // Update the out-of-date identifiers. for (unsigned I = 0, N = OutOfDate.size(); I != N; ++I) { ExtSource->updateOutOfDateIdentifier(*OutOfDate[I]); } } // Build a record containing all of the tentative definitions in this file, in // TentativeDefinitions order. Generally, this record will be empty for // headers. RecordData TentativeDefinitions; AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions); // Build a record containing all of the file scoped decls in this file. RecordData UnusedFileScopedDecls; if (!isModule) AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls, UnusedFileScopedDecls); // Build a record containing all of the delegating constructors we still need // to resolve. RecordData DelegatingCtorDecls; if (!isModule) AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls); // Write the set of weak, undeclared identifiers. We always write the // entire table, since later PCH files in a PCH chain are only interested in // the results at the end of the chain. RecordData WeakUndeclaredIdentifiers; if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { for (llvm::DenseMap::iterator I = SemaRef.WeakUndeclaredIdentifiers.begin(), E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); } } // Build a record containing all of the locally-scoped extern "C" // declarations in this header file. Generally, this record will be // empty. RecordData LocallyScopedExternCDecls; // FIXME: This is filling in the AST file in densemap order which is // nondeterminstic! for (llvm::DenseMap::iterator TD = SemaRef.LocallyScopedExternCDecls.begin(), TDEnd = SemaRef.LocallyScopedExternCDecls.end(); TD != TDEnd; ++TD) { if (!TD->second->isFromASTFile()) AddDeclRef(TD->second, LocallyScopedExternCDecls); } // Build a record containing all of the ext_vector declarations. RecordData ExtVectorDecls; AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls); // Build a record containing all of the VTable uses information. RecordData VTableUses; if (!SemaRef.VTableUses.empty()) { for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); } } // Build a record containing all of dynamic classes declarations. RecordData DynamicClasses; AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses); // Build a record containing all of pending implicit instantiations. RecordData PendingInstantiations; for (std::deque::iterator I = SemaRef.PendingInstantiations.begin(), N = SemaRef.PendingInstantiations.end(); I != N; ++I) { AddDeclRef(I->first, PendingInstantiations); AddSourceLocation(I->second, PendingInstantiations); } assert(SemaRef.PendingLocalImplicitInstantiations.empty() && "There are local ones at end of translation unit!"); // Build a record containing some declaration references. RecordData SemaDeclRefs; if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); } RecordData CUDASpecialDeclRefs; if (Context.getcudaConfigureCallDecl()) { AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); } // Build a record containing all of the known namespaces. RecordData KnownNamespaces; for (llvm::MapVector::iterator I = SemaRef.KnownNamespaces.begin(), IEnd = SemaRef.KnownNamespaces.end(); I != IEnd; ++I) { if (!I->second) AddDeclRef(I->first, KnownNamespaces); } // Build a record of all used, undefined objects that require definitions. RecordData UndefinedButUsed; SmallVector, 16> Undefined; SemaRef.getUndefinedButUsed(Undefined); for (SmallVectorImpl >::iterator I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { AddDeclRef(I->first, UndefinedButUsed); AddSourceLocation(I->second, UndefinedButUsed); } // Write the control block WriteControlBlock(PP, Context, isysroot, OutputFile); // Write the remaining AST contents. RecordData Record; Stream.EnterSubblock(AST_BLOCK_ID, 5); // This is so that older clang versions, before the introduction // of the control block, can read and reject the newer PCH format. Record.clear(); Record.push_back(VERSION_MAJOR); Stream.EmitRecord(METADATA_OLD_FORMAT, Record); // Create a lexical update block containing all of the declarations in the // translation unit that do not come from other AST files. const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); SmallVector NewGlobalDecls; for (DeclContext::decl_iterator I = TU->noload_decls_begin(), E = TU->noload_decls_end(); I != E; ++I) { if (!(*I)->isFromASTFile()) NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I))); } llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); Record.clear(); Record.push_back(TU_UPDATE_LEXICAL); Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, data(NewGlobalDecls)); // And a visible updates block for the translation unit. Abv = new llvm::BitCodeAbbrev(); Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv); WriteDeclContextVisibleUpdate(TU); // If the translation unit has an anonymous namespace, and we don't already // have an update block for it, write it as an update block. if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; if (Record.empty()) { Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE); Record.push_back(reinterpret_cast(NS)); } } // Make sure visible decls, added to DeclContexts previously loaded from // an AST file, are registered for serialization. for (SmallVectorImpl::iterator I = UpdatingVisibleDecls.begin(), E = UpdatingVisibleDecls.end(); I != E; ++I) { GetDeclRef(*I); } // Make sure all decls associated with an identifier are registered for // serialization. for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) { const IdentifierInfo *II = ID->second; if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) { for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), DEnd = SemaRef.IdResolver.end(); D != DEnd; ++D) { GetDeclRef(*D); } } } // Resolve any declaration pointers within the declaration updates block. ResolveDeclUpdatesBlocks(); // Form the record of special types. RecordData SpecialTypes; AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); AddTypeRef(Context.getFILEType(), SpecialTypes); AddTypeRef(Context.getjmp_bufType(), SpecialTypes); AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes); AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes); AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); AddTypeRef(Context.getucontext_tType(), SpecialTypes); // Keep writing types and declarations until all types and // declarations have been written. Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); WriteDeclsBlockAbbrevs(); for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(), E = DeclsToRewrite.end(); I != E; ++I) DeclTypesToEmit.push(const_cast(*I)); while (!DeclTypesToEmit.empty()) { DeclOrType DOT = DeclTypesToEmit.front(); DeclTypesToEmit.pop(); if (DOT.isType()) WriteType(DOT.getType()); else WriteDecl(Context, DOT.getDecl()); } Stream.ExitBlock(); DoneWritingDeclsAndTypes = true; WriteFileDeclIDsMap(); WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); WriteComments(); if (Chain) { // Write the mapping information describing our module dependencies and how // each of those modules were mapped into our own offset/ID space, so that // the reader can build the appropriate mapping to its own offset/ID space. // The map consists solely of a blob with the following format: // *(module-name-len:i16 module-name:len*i8 // source-location-offset:i32 // identifier-id:i32 // preprocessed-entity-id:i32 // macro-definition-id:i32 // submodule-id:i32 // selector-id:i32 // declaration-id:i32 // c++-base-specifiers-id:i32 // type-id:i32) // llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); SmallString<2048> Buffer; { llvm::raw_svector_ostream Out(Buffer); for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), MEnd = Chain->ModuleMgr.end(); M != MEnd; ++M) { StringRef FileName = (*M)->FileName; io::Emit16(Out, FileName.size()); Out.write(FileName.data(), FileName.size()); io::Emit32(Out, (*M)->SLocEntryBaseOffset); io::Emit32(Out, (*M)->BaseIdentifierID); io::Emit32(Out, (*M)->BaseMacroID); io::Emit32(Out, (*M)->BasePreprocessedEntityID); io::Emit32(Out, (*M)->BaseSubmoduleID); io::Emit32(Out, (*M)->BaseSelectorID); io::Emit32(Out, (*M)->BaseDeclID); io::Emit32(Out, (*M)->BaseTypeIndex); } } Record.clear(); Record.push_back(MODULE_OFFSET_MAP); Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, Buffer.data(), Buffer.size()); } WritePreprocessor(PP, isModule); WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot); WriteSelectors(SemaRef); WriteReferencedSelectorsPool(SemaRef); WriteIdentifierTable(PP, SemaRef.IdResolver, isModule); WriteFPPragmaOptions(SemaRef.getFPOptions()); WriteOpenCLExtensions(SemaRef); WriteTypeDeclOffsets(); WritePragmaDiagnosticMappings(Context.getDiagnostics(), isModule); WriteCXXBaseSpecifiersOffsets(); // If we're emitting a module, write out the submodule information. if (WritingModule) WriteSubmodules(WritingModule); Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); // Write the record containing external, unnamed definitions. if (!ExternalDefinitions.empty()) Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions); // Write the record containing tentative definitions. if (!TentativeDefinitions.empty()) Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); // Write the record containing unused file scoped decls. if (!UnusedFileScopedDecls.empty()) Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); // Write the record containing weak undeclared identifiers. if (!WeakUndeclaredIdentifiers.empty()) Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, WeakUndeclaredIdentifiers); // Write the record containing locally-scoped extern "C" definitions. if (!LocallyScopedExternCDecls.empty()) Stream.EmitRecord(LOCALLY_SCOPED_EXTERN_C_DECLS, LocallyScopedExternCDecls); // Write the record containing ext_vector type names. if (!ExtVectorDecls.empty()) Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); // Write the record containing VTable uses information. if (!VTableUses.empty()) Stream.EmitRecord(VTABLE_USES, VTableUses); // Write the record containing dynamic classes declarations. if (!DynamicClasses.empty()) Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); // Write the record containing pending implicit instantiations. if (!PendingInstantiations.empty()) Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); // Write the record containing declaration references of Sema. if (!SemaDeclRefs.empty()) Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); // Write the record containing CUDA-specific declaration references. if (!CUDASpecialDeclRefs.empty()) Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); // Write the delegating constructors. if (!DelegatingCtorDecls.empty()) Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls); // Write the known namespaces. if (!KnownNamespaces.empty()) Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces); // Write the undefined internal functions and variables, and inline functions. if (!UndefinedButUsed.empty()) Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed); // Write the visible updates to DeclContexts. for (llvm::SmallPtrSet::iterator I = UpdatedDeclContexts.begin(), E = UpdatedDeclContexts.end(); I != E; ++I) WriteDeclContextVisibleUpdate(*I); if (!WritingModule) { // Write the submodules that were imported, if any. RecordData ImportedModules; for (ASTContext::import_iterator I = Context.local_import_begin(), IEnd = Context.local_import_end(); I != IEnd; ++I) { assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); ImportedModules.push_back(SubmoduleIDs[I->getImportedModule()]); } if (!ImportedModules.empty()) { // Sort module IDs. llvm::array_pod_sort(ImportedModules.begin(), ImportedModules.end()); // Unique module IDs. ImportedModules.erase(std::unique(ImportedModules.begin(), ImportedModules.end()), ImportedModules.end()); Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); } } WriteDeclUpdatesBlocks(); WriteDeclReplacementsBlock(); WriteRedeclarations(); WriteMergedDecls(); WriteObjCCategories(); WriteLateParsedTemplates(SemaRef); // Some simple statistics Record.clear(); Record.push_back(NumStatements); Record.push_back(NumMacros); Record.push_back(NumLexicalDeclContexts); Record.push_back(NumVisibleDeclContexts); Stream.EmitRecord(STATISTICS, Record); Stream.ExitBlock(); } /// \brief Go through the declaration update blocks and resolve declaration /// pointers into declaration IDs. void ASTWriter::ResolveDeclUpdatesBlocks() { for (DeclUpdateMap::iterator I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { const Decl *D = I->first; UpdateRecord &URec = I->second; if (isRewritten(D)) continue; // The decl will be written completely unsigned Idx = 0, N = URec.size(); while (Idx < N) { switch ((DeclUpdateKind)URec[Idx++]) { case UPD_CXX_ADDED_IMPLICIT_MEMBER: case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: URec[Idx] = GetDeclRef(reinterpret_cast(URec[Idx])); ++Idx; break; case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: case UPD_DECL_MARKED_USED: ++Idx; break; case UPD_CXX_DEDUCED_RETURN_TYPE: URec[Idx] = GetOrCreateTypeID( QualType::getFromOpaquePtr(reinterpret_cast(URec[Idx]))); ++Idx; break; } } } } void ASTWriter::WriteDeclUpdatesBlocks() { if (DeclUpdates.empty()) return; RecordData OffsetsRecord; Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); for (DeclUpdateMap::iterator I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { const Decl *D = I->first; UpdateRecord &URec = I->second; if (isRewritten(D)) continue; // The decl will be written completely,no need to store updates. uint64_t Offset = Stream.GetCurrentBitNo(); Stream.EmitRecord(DECL_UPDATES, URec); OffsetsRecord.push_back(GetDeclRef(D)); OffsetsRecord.push_back(Offset); } Stream.ExitBlock(); Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord); } void ASTWriter::WriteDeclReplacementsBlock() { if (ReplacedDecls.empty()) return; RecordData Record; for (SmallVectorImpl::iterator I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { Record.push_back(I->ID); Record.push_back(I->Offset); Record.push_back(I->Loc); } Stream.EmitRecord(DECL_REPLACEMENTS, Record); } void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { Record.push_back(Loc.getRawEncoding()); } void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { AddSourceLocation(Range.getBegin(), Record); AddSourceLocation(Range.getEnd(), Record); } void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) { Record.push_back(Value.getBitWidth()); const uint64_t *Words = Value.getRawData(); Record.append(Words, Words + Value.getNumWords()); } void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) { Record.push_back(Value.isUnsigned()); AddAPInt(Value, Record); } void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) { AddAPInt(Value.bitcastToAPInt(), Record); } void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { Record.push_back(getIdentifierRef(II)); } IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { if (II == 0) return 0; IdentID &ID = IdentifierIDs[II]; if (ID == 0) ID = NextIdentID++; return ID; } MacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) { // Don't emit builtin macros like __LINE__ to the AST file unless they // have been redefined by the header (in which case they are not // isBuiltinMacro). if (MI == 0 || MI->isBuiltinMacro()) return 0; MacroID &ID = MacroIDs[MI]; if (ID == 0) { ID = NextMacroID++; MacroInfoToEmitData Info = { Name, MI, ID }; MacroInfosToEmit.push_back(Info); } return ID; } MacroID ASTWriter::getMacroID(MacroInfo *MI) { if (MI == 0 || MI->isBuiltinMacro()) return 0; assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!"); return MacroIDs[MI]; } uint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) { assert(IdentMacroDirectivesOffsetMap[Name] && "not set!"); return IdentMacroDirectivesOffsetMap[Name]; } void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) { Record.push_back(getSelectorRef(SelRef)); } SelectorID ASTWriter::getSelectorRef(Selector Sel) { if (Sel.getAsOpaquePtr() == 0) { return 0; } SelectorID SID = SelectorIDs[Sel]; if (SID == 0 && Chain) { // This might trigger a ReadSelector callback, which will set the ID for // this selector. Chain->LoadSelector(Sel); SID = SelectorIDs[Sel]; } if (SID == 0) { SID = NextSelectorID++; SelectorIDs[Sel] = SID; } return SID; } void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) { AddDeclRef(Temp->getDestructor(), Record); } void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases, CXXBaseSpecifier const *BasesEnd, RecordDataImpl &Record) { assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded"); CXXBaseSpecifiersToWrite.push_back( QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID, Bases, BasesEnd)); Record.push_back(NextCXXBaseSpecifiersID++); } void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg, RecordDataImpl &Record) { switch (Kind) { case TemplateArgument::Expression: AddStmt(Arg.getAsExpr()); break; case TemplateArgument::Type: AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record); break; case TemplateArgument::Template: AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); AddSourceLocation(Arg.getTemplateNameLoc(), Record); break; case TemplateArgument::TemplateExpansion: AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); AddSourceLocation(Arg.getTemplateNameLoc(), Record); AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record); break; case TemplateArgument::Null: case TemplateArgument::Integral: case TemplateArgument::Declaration: case TemplateArgument::NullPtr: case TemplateArgument::Pack: // FIXME: Is this right? break; } } void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, RecordDataImpl &Record) { AddTemplateArgument(Arg.getArgument(), Record); if (Arg.getArgument().getKind() == TemplateArgument::Expression) { bool InfoHasSameExpr = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); Record.push_back(InfoHasSameExpr); if (InfoHasSameExpr) return; // Avoid storing the same expr twice. } AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(), Record); } void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordDataImpl &Record) { if (TInfo == 0) { AddTypeRef(QualType(), Record); return; } AddTypeLoc(TInfo->getTypeLoc(), Record); } void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) { AddTypeRef(TL.getType(), Record); TypeLocWriter TLW(*this, Record); for (; !TL.isNull(); TL = TL.getNextTypeLoc()) TLW.Visit(TL); } void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { Record.push_back(GetOrCreateTypeID(T)); } TypeID ASTWriter::GetOrCreateTypeID( QualType T) { assert(Context); return MakeTypeID(*Context, T, std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this)); } TypeID ASTWriter::getTypeID(QualType T) const { assert(Context); return MakeTypeID(*Context, T, std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this)); } TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); TypeIdx &Idx = TypeIdxs[T]; if (Idx.getIndex() == 0) { if (DoneWritingDeclsAndTypes) { assert(0 && "New type seen after serializing all the types to emit!"); return TypeIdx(); } // We haven't seen this type before. Assign it a new ID and put it // into the queue of types to emit. Idx = TypeIdx(NextTypeID++); DeclTypesToEmit.push(T); } return Idx; } TypeIdx ASTWriter::getTypeIdx(QualType T) const { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); TypeIdxMap::const_iterator I = TypeIdxs.find(T); assert(I != TypeIdxs.end() && "Type not emitted!"); return I->second; } void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { Record.push_back(GetDeclRef(D)); } DeclID ASTWriter::GetDeclRef(const Decl *D) { assert(WritingAST && "Cannot request a declaration ID before AST writing"); if (D == 0) { return 0; } // If D comes from an AST file, its declaration ID is already known and // fixed. if (D->isFromASTFile()) return D->getGlobalID(); assert(!(reinterpret_cast(D) & 0x01) && "Invalid decl pointer"); DeclID &ID = DeclIDs[D]; if (ID == 0) { if (DoneWritingDeclsAndTypes) { assert(0 && "New decl seen after serializing all the decls to emit!"); return 0; } // We haven't seen this declaration before. Give it a new ID and // enqueue it in the list of declarations to emit. ID = NextDeclID++; DeclTypesToEmit.push(const_cast(D)); } return ID; } DeclID ASTWriter::getDeclID(const Decl *D) { if (D == 0) return 0; // If D comes from an AST file, its declaration ID is already known and // fixed. if (D->isFromASTFile()) return D->getGlobalID(); assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); return DeclIDs[D]; } void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { assert(ID); assert(D); SourceLocation Loc = D->getLocation(); if (Loc.isInvalid()) return; // We only keep track of the file-level declarations of each file. if (!D->getLexicalDeclContext()->isFileContext()) return; // FIXME: ParmVarDecls that are part of a function type of a parameter of // a function/objc method, should not have TU as lexical context. if (isa(D)) return; SourceManager &SM = Context->getSourceManager(); SourceLocation FileLoc = SM.getFileLoc(Loc); assert(SM.isLocalSourceLocation(FileLoc)); FileID FID; unsigned Offset; llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); if (FID.isInvalid()) return; assert(SM.getSLocEntry(FID).isFile()); DeclIDInFileInfo *&Info = FileDeclIDs[FID]; if (!Info) Info = new DeclIDInFileInfo(); std::pair LocDecl(Offset, ID); LocDeclIDsTy &Decls = Info->DeclIDs; if (Decls.empty() || Decls.back().first <= Offset) { Decls.push_back(LocDecl); return; } LocDeclIDsTy::iterator I = std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first()); Decls.insert(I, LocDecl); } void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) { // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. Record.push_back(Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: AddIdentifierRef(Name.getAsIdentifierInfo(), Record); break; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: AddSelectorRef(Name.getObjCSelector(), Record); break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: AddTypeRef(Name.getCXXNameType(), Record); break; case DeclarationName::CXXOperatorName: Record.push_back(Name.getCXXOverloadedOperator()); break; case DeclarationName::CXXLiteralOperatorName: AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record); break; case DeclarationName::CXXUsingDirective: // No extra data to emit break; } } void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name, RecordDataImpl &Record) { switch (Name.getNameKind()) { case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record); break; case DeclarationName::CXXOperatorName: AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc), Record); AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc), Record); break; case DeclarationName::CXXLiteralOperatorName: AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc), Record); break; case DeclarationName::Identifier: case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: case DeclarationName::CXXUsingDirective: break; } } void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo, RecordDataImpl &Record) { AddDeclarationName(NameInfo.getName(), Record); AddSourceLocation(NameInfo.getLoc(), Record); AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record); } void ASTWriter::AddQualifierInfo(const QualifierInfo &Info, RecordDataImpl &Record) { AddNestedNameSpecifierLoc(Info.QualifierLoc, Record); Record.push_back(Info.NumTemplParamLists); for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i) AddTemplateParameterList(Info.TemplParamLists[i], Record); } void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS, RecordDataImpl &Record) { // Nested name specifiers usually aren't too long. I think that 8 would // typically accommodate the vast majority. SmallVector NestedNames; // Push each of the NNS's onto a stack for serialization in reverse order. while (NNS) { NestedNames.push_back(NNS); NNS = NNS->getPrefix(); } Record.push_back(NestedNames.size()); while(!NestedNames.empty()) { NNS = NestedNames.pop_back_val(); NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); Record.push_back(Kind); switch (Kind) { case NestedNameSpecifier::Identifier: AddIdentifierRef(NNS->getAsIdentifier(), Record); break; case NestedNameSpecifier::Namespace: AddDeclRef(NNS->getAsNamespace(), Record); break; case NestedNameSpecifier::NamespaceAlias: AddDeclRef(NNS->getAsNamespaceAlias(), Record); break; case NestedNameSpecifier::TypeSpec: case NestedNameSpecifier::TypeSpecWithTemplate: AddTypeRef(QualType(NNS->getAsType(), 0), Record); Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); break; case NestedNameSpecifier::Global: // Don't need to write an associated value. break; } } } void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, RecordDataImpl &Record) { // Nested name specifiers usually aren't too long. I think that 8 would // typically accommodate the vast majority. SmallVector NestedNames; // Push each of the nested-name-specifiers's onto a stack for // serialization in reverse order. while (NNS) { NestedNames.push_back(NNS); NNS = NNS.getPrefix(); } Record.push_back(NestedNames.size()); while(!NestedNames.empty()) { NNS = NestedNames.pop_back_val(); NestedNameSpecifier::SpecifierKind Kind = NNS.getNestedNameSpecifier()->getKind(); Record.push_back(Kind); switch (Kind) { case NestedNameSpecifier::Identifier: AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::Namespace: AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::NamespaceAlias: AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::TypeSpec: case NestedNameSpecifier::TypeSpecWithTemplate: Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); AddTypeLoc(NNS.getTypeLoc(), Record); AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); break; case NestedNameSpecifier::Global: AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); break; } } } void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) { TemplateName::NameKind Kind = Name.getKind(); Record.push_back(Kind); switch (Kind) { case TemplateName::Template: AddDeclRef(Name.getAsTemplateDecl(), Record); break; case TemplateName::OverloadedTemplate: { OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); Record.push_back(OvT->size()); for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end(); I != E; ++I) AddDeclRef(*I, Record); break; } case TemplateName::QualifiedTemplate: { QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); AddNestedNameSpecifier(QualT->getQualifier(), Record); Record.push_back(QualT->hasTemplateKeyword()); AddDeclRef(QualT->getTemplateDecl(), Record); break; } case TemplateName::DependentTemplate: { DependentTemplateName *DepT = Name.getAsDependentTemplateName(); AddNestedNameSpecifier(DepT->getQualifier(), Record); Record.push_back(DepT->isIdentifier()); if (DepT->isIdentifier()) AddIdentifierRef(DepT->getIdentifier(), Record); else Record.push_back(DepT->getOperator()); break; } case TemplateName::SubstTemplateTemplateParm: { SubstTemplateTemplateParmStorage *subst = Name.getAsSubstTemplateTemplateParm(); AddDeclRef(subst->getParameter(), Record); AddTemplateName(subst->getReplacement(), Record); break; } case TemplateName::SubstTemplateTemplateParmPack: { SubstTemplateTemplateParmPackStorage *SubstPack = Name.getAsSubstTemplateTemplateParmPack(); AddDeclRef(SubstPack->getParameterPack(), Record); AddTemplateArgument(SubstPack->getArgumentPack(), Record); break; } } } void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, RecordDataImpl &Record) { Record.push_back(Arg.getKind()); switch (Arg.getKind()) { case TemplateArgument::Null: break; case TemplateArgument::Type: AddTypeRef(Arg.getAsType(), Record); break; case TemplateArgument::Declaration: AddDeclRef(Arg.getAsDecl(), Record); Record.push_back(Arg.isDeclForReferenceParam()); break; case TemplateArgument::NullPtr: AddTypeRef(Arg.getNullPtrType(), Record); break; case TemplateArgument::Integral: AddAPSInt(Arg.getAsIntegral(), Record); AddTypeRef(Arg.getIntegralType(), Record); break; case TemplateArgument::Template: AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); break; case TemplateArgument::TemplateExpansion: AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); if (Optional NumExpansions = Arg.getNumTemplateExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); break; case TemplateArgument::Expression: AddStmt(Arg.getAsExpr()); break; case TemplateArgument::Pack: Record.push_back(Arg.pack_size()); for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); I != E; ++I) AddTemplateArgument(*I, Record); break; } } void ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams, RecordDataImpl &Record) { assert(TemplateParams && "No TemplateParams!"); AddSourceLocation(TemplateParams->getTemplateLoc(), Record); AddSourceLocation(TemplateParams->getLAngleLoc(), Record); AddSourceLocation(TemplateParams->getRAngleLoc(), Record); Record.push_back(TemplateParams->size()); for (TemplateParameterList::const_iterator P = TemplateParams->begin(), PEnd = TemplateParams->end(); P != PEnd; ++P) AddDeclRef(*P, Record); } /// \brief Emit a template argument list. void ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs, RecordDataImpl &Record) { assert(TemplateArgs && "No TemplateArgs!"); Record.push_back(TemplateArgs->size()); for (int i=0, e = TemplateArgs->size(); i != e; ++i) AddTemplateArgument(TemplateArgs->get(i), Record); } void ASTWriter::AddASTTemplateArgumentListInfo (const ASTTemplateArgumentListInfo *ASTTemplArgList, RecordDataImpl &Record) { assert(ASTTemplArgList && "No ASTTemplArgList!"); AddSourceLocation(ASTTemplArgList->LAngleLoc, Record); AddSourceLocation(ASTTemplArgList->RAngleLoc, Record); Record.push_back(ASTTemplArgList->NumTemplateArgs); const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs(); for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) AddTemplateArgumentLoc(TemplArgs[i], Record); } void ASTWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record) { Record.push_back(Set.size()); for (ASTUnresolvedSet::const_iterator I = Set.begin(), E = Set.end(); I != E; ++I) { AddDeclRef(I.getDecl(), Record); Record.push_back(I.getAccess()); } } void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, RecordDataImpl &Record) { Record.push_back(Base.isVirtual()); Record.push_back(Base.isBaseOfClass()); Record.push_back(Base.getAccessSpecifierAsWritten()); Record.push_back(Base.getInheritConstructors()); AddTypeSourceInfo(Base.getTypeSourceInfo(), Record); AddSourceRange(Base.getSourceRange(), Record); AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() : SourceLocation(), Record); } void ASTWriter::FlushCXXBaseSpecifiers() { RecordData Record; for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) { Record.clear(); // Record the offset of this base-specifier set. unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1; if (Index == CXXBaseSpecifiersOffsets.size()) CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo()); else { if (Index > CXXBaseSpecifiersOffsets.size()) CXXBaseSpecifiersOffsets.resize(Index + 1); CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo(); } const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases, *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd; Record.push_back(BEnd - B); for (; B != BEnd; ++B) AddCXXBaseSpecifier(*B, Record); Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record); // Flush any expressions that were written as part of the base specifiers. FlushStmts(); } CXXBaseSpecifiersToWrite.clear(); } void ASTWriter::AddCXXCtorInitializers( const CXXCtorInitializer * const *CtorInitializers, unsigned NumCtorInitializers, RecordDataImpl &Record) { Record.push_back(NumCtorInitializers); for (unsigned i=0; i != NumCtorInitializers; ++i) { const CXXCtorInitializer *Init = CtorInitializers[i]; if (Init->isBaseInitializer()) { Record.push_back(CTOR_INITIALIZER_BASE); AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); Record.push_back(Init->isBaseVirtual()); } else if (Init->isDelegatingInitializer()) { Record.push_back(CTOR_INITIALIZER_DELEGATING); AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); } else if (Init->isMemberInitializer()){ Record.push_back(CTOR_INITIALIZER_MEMBER); AddDeclRef(Init->getMember(), Record); } else { Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); AddDeclRef(Init->getIndirectMember(), Record); } AddSourceLocation(Init->getMemberLocation(), Record); AddStmt(Init->getInit()); AddSourceLocation(Init->getLParenLoc(), Record); AddSourceLocation(Init->getRParenLoc(), Record); Record.push_back(Init->isWritten()); if (Init->isWritten()) { Record.push_back(Init->getSourceOrder()); } else { Record.push_back(Init->getNumArrayIndices()); for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i) AddDeclRef(Init->getArrayIndex(i), Record); } } } void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) { assert(D->DefinitionData); struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData; Record.push_back(Data.IsLambda); Record.push_back(Data.UserDeclaredConstructor); Record.push_back(Data.UserDeclaredSpecialMembers); Record.push_back(Data.Aggregate); Record.push_back(Data.PlainOldData); Record.push_back(Data.Empty); Record.push_back(Data.Polymorphic); Record.push_back(Data.Abstract); Record.push_back(Data.IsStandardLayout); Record.push_back(Data.HasNoNonEmptyBases); Record.push_back(Data.HasPrivateFields); Record.push_back(Data.HasProtectedFields); Record.push_back(Data.HasPublicFields); Record.push_back(Data.HasMutableFields); Record.push_back(Data.HasOnlyCMembers); Record.push_back(Data.HasInClassInitializer); Record.push_back(Data.HasUninitializedReferenceMember); Record.push_back(Data.NeedOverloadResolutionForMoveConstructor); Record.push_back(Data.NeedOverloadResolutionForMoveAssignment); Record.push_back(Data.NeedOverloadResolutionForDestructor); Record.push_back(Data.DefaultedMoveConstructorIsDeleted); Record.push_back(Data.DefaultedMoveAssignmentIsDeleted); Record.push_back(Data.DefaultedDestructorIsDeleted); Record.push_back(Data.HasTrivialSpecialMembers); Record.push_back(Data.HasIrrelevantDestructor); Record.push_back(Data.HasConstexprNonCopyMoveConstructor); Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr); Record.push_back(Data.HasConstexprDefaultConstructor); Record.push_back(Data.HasNonLiteralTypeFieldsOrBases); Record.push_back(Data.ComputedVisibleConversions); Record.push_back(Data.UserProvidedDefaultConstructor); Record.push_back(Data.DeclaredSpecialMembers); Record.push_back(Data.ImplicitCopyConstructorHasConstParam); Record.push_back(Data.ImplicitCopyAssignmentHasConstParam); Record.push_back(Data.HasDeclaredCopyConstructorWithConstParam); Record.push_back(Data.HasDeclaredCopyAssignmentWithConstParam); // IsLambda bit is already saved. Record.push_back(Data.NumBases); if (Data.NumBases > 0) AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases, Record); // FIXME: Make VBases lazily computed when needed to avoid storing them. Record.push_back(Data.NumVBases); if (Data.NumVBases > 0) AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases, Record); AddUnresolvedSet(Data.Conversions.get(*Context), Record); AddUnresolvedSet(Data.VisibleConversions.get(*Context), Record); // Data.Definition is the owning decl, no need to write it. AddDeclRef(D->getFirstFriend(), Record); // Add lambda-specific data. if (Data.IsLambda) { CXXRecordDecl::LambdaDefinitionData &Lambda = D->getLambdaData(); Record.push_back(Lambda.Dependent); Record.push_back(Lambda.IsGenericLambda); Record.push_back(Lambda.CaptureDefault); Record.push_back(Lambda.NumCaptures); Record.push_back(Lambda.NumExplicitCaptures); Record.push_back(Lambda.ManglingNumber); AddDeclRef(Lambda.ContextDecl, Record); AddTypeSourceInfo(Lambda.MethodTyInfo, Record); for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { LambdaExpr::Capture &Capture = Lambda.Captures[I]; AddSourceLocation(Capture.getLocation(), Record); Record.push_back(Capture.isImplicit()); Record.push_back(Capture.getCaptureKind()); switch (Capture.getCaptureKind()) { case LCK_This: break; case LCK_ByCopy: case LCK_ByRef: VarDecl *Var = Capture.capturesVariable() ? Capture.getCapturedVar() : 0; AddDeclRef(Var, Record); AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc() : SourceLocation(), Record); break; } } } } void ASTWriter::ReaderInitialized(ASTReader *Reader) { assert(Reader && "Cannot remove chain"); assert((!Chain || Chain == Reader) && "Cannot replace chain"); assert(FirstDeclID == NextDeclID && FirstTypeID == NextTypeID && FirstIdentID == NextIdentID && FirstMacroID == NextMacroID && FirstSubmoduleID == NextSubmoduleID && FirstSelectorID == NextSelectorID && "Setting chain after writing has started."); Chain = Reader; FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros(); FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); NextDeclID = FirstDeclID; NextTypeID = FirstTypeID; NextIdentID = FirstIdentID; NextMacroID = FirstMacroID; NextSelectorID = FirstSelectorID; NextSubmoduleID = FirstSubmoduleID; } void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { // Always keep the highest ID. See \p TypeRead() for more information. IdentID &StoredID = IdentifierIDs[II]; if (ID > StoredID) StoredID = ID; } void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) { // Always keep the highest ID. See \p TypeRead() for more information. MacroID &StoredID = MacroIDs[MI]; if (ID > StoredID) StoredID = ID; } void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { // Always take the highest-numbered type index. This copes with an interesting // case for chained AST writing where we schedule writing the type and then, // later, deserialize the type from another AST. In this case, we want to // keep the higher-numbered entry so that we can properly write it out to // the AST file. TypeIdx &StoredIdx = TypeIdxs[T]; if (Idx.getIndex() >= StoredIdx.getIndex()) StoredIdx = Idx; } void ASTWriter::SelectorRead(SelectorID ID, Selector S) { // Always keep the highest ID. See \p TypeRead() for more information. SelectorID &StoredID = SelectorIDs[S]; if (ID > StoredID) StoredID = ID; } void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, MacroDefinition *MD) { assert(MacroDefinitions.find(MD) == MacroDefinitions.end()); MacroDefinitions[MD] = ID; } void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); SubmoduleIDs[Mod] = ID; } void ASTWriter::CompletedTagDefinition(const TagDecl *D) { assert(D->isCompleteDefinition()); assert(!WritingAST && "Already writing the AST!"); if (const CXXRecordDecl *RD = dyn_cast(D)) { // We are interested when a PCH decl is modified. if (RD->isFromASTFile()) { // A forward reference was mutated into a definition. Rewrite it. // FIXME: This happens during template instantiation, should we // have created a new definition decl instead ? RewriteDecl(RD); } } } void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { assert(!WritingAST && "Already writing the AST!"); // TU and namespaces are handled elsewhere. if (isa(DC) || isa(DC)) return; if (!(!D->isFromASTFile() && cast(DC)->isFromASTFile())) return; // Not a source decl added to a DeclContext from PCH. assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!"); AddUpdatedDeclContext(DC); UpdatingVisibleDecls.push_back(D); } void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { assert(!WritingAST && "Already writing the AST!"); assert(D->isImplicit()); if (!(!D->isFromASTFile() && RD->isFromASTFile())) return; // Not a source member added to a class from PCH. if (!isa(D)) return; // We are interested in lazily declared implicit methods. // A decl coming from PCH was modified. assert(RD->isCompleteDefinition()); UpdateRecord &Record = DeclUpdates[RD]; Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER); Record.push_back(reinterpret_cast(D)); } void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. UpdateRecord &Record = DeclUpdates[TD]; Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); Record.push_back(reinterpret_cast(D)); } void ASTWriter::AddedCXXTemplateSpecialization( const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. UpdateRecord &Record = DeclUpdates[TD]; Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); Record.push_back(reinterpret_cast(D)); } void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, const FunctionDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. UpdateRecord &Record = DeclUpdates[TD]; Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); Record.push_back(reinterpret_cast(D)); } void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { assert(!WritingAST && "Already writing the AST!"); FD = FD->getCanonicalDecl(); if (!FD->isFromASTFile()) return; // Not a function declared in PCH and defined outside. UpdateRecord &Record = DeclUpdates[FD]; Record.push_back(UPD_CXX_DEDUCED_RETURN_TYPE); Record.push_back(reinterpret_cast(ReturnType.getAsOpaquePtr())); } void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Declaration not imported from PCH. // Implicit decl from a PCH was defined. // FIXME: Should implicit definition be a separate FunctionDecl? RewriteDecl(D); } void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Since the actual instantiation is delayed, this really means that we need // to update the instantiation location. UpdateRecord &Record = DeclUpdates[D]; Record.push_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER); AddSourceLocation( D->getMemberSpecializationInfo()->getPointOfInstantiation(), Record); } void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, const ObjCInterfaceDecl *IFD) { assert(!WritingAST && "Already writing the AST!"); if (!IFD->isFromASTFile()) return; // Declaration not imported from PCH. assert(IFD->getDefinition() && "Category on a class without a definition?"); ObjCClassesWithCategories.insert( const_cast(IFD->getDefinition())); } void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, const ObjCPropertyDecl *OrigProp, const ObjCCategoryDecl *ClassExt) { const ObjCInterfaceDecl *D = ClassExt->getClassInterface(); if (!D) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Declaration not imported from PCH. RewriteDecl(D); } void ASTWriter::DeclarationMarkedUsed(const Decl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; UpdateRecord &Record = DeclUpdates[D]; Record.push_back(UPD_DECL_MARKED_USED); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @a115 6 void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) { Writer.AddTypeRef(T->getOriginalType(), Record); Writer.AddTypeRef(T->getAdjustedType(), Record); Code = TYPE_ADJUSTED; } a457 3 void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { // nothing to do } d767 1 d770 1 d1043 1 a5086 1 Record.push_back(Data.HasVariantMembers); @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d1106 1 @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @d182 1 a182 1 Writer.AddTypeRef(T->getReturnType(), Record); d199 3 a201 3 Record.push_back(T->getNumParams()); for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Writer.AddTypeRef(T->getParamType(I), Record); d515 2 a516 2 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) Writer.AddDeclRef(TL.getParam(i), Record); d816 1 a816 1 RECORD(EAGERLY_DESERIALIZED_DECLS); d1954 2 d2998 3 d4200 2 a4201 2 if (!EagerlyDeserializedDecls.empty()) Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls); @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @d2965 2 a2966 4 typedef llvm::SmallVectorImpl OverriddenList; MacroDirective * getFirstPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID) { d2968 3 a2970 4 llvm::SmallVector Overridden; if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD, ModID, Overridden)) if (!shouldIgnoreMacro(NextMD, IsModule, PP)) return NextMD; d2974 6 a2979 7 MacroDirective * getNextPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID, OverriddenList &Overridden) { if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD->getPrevious(), ModID, Overridden)) if (!shouldIgnoreMacro(NextMD, IsModule, PP)) return NextMD; d2984 2 a2985 2 /// public macro definition or undefinition that is not in ModID. /// A macro that is defined in submodule A and undefined in submodule B d2987 2 a2988 8 /// ModID is updated to the module containing the returned directive. /// /// FIXME: This process breaks down if a module defines a macro, imports /// another submodule that changes the macro, then changes the /// macro again itself. MacroDirective *getPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID, OverriddenList &Overridden) { a2991 1 Overridden.clear(); d2993 2 a2994 1 Optional IsPublic; d2998 2 a2999 1 IsPublic = Optional(); d3002 1 a3002 1 if (ThisModID != ModID) { d3004 2 a3005 1 IsPublic = Optional(); a3006 12 // If this is a definition from a submodule import, that submodule's // definition is overridden by the definition or undefinition that we // started with. // FIXME: This should only apply to macros defined in OrigModID. // We can't do that currently, because a #include of a different submodule // of the same module just leaks through macros instead of providing new // DefMacroDirectives for them. if (DefMacroDirective *DefMD = dyn_cast(MD)) if (SubmoduleID SourceID = DefMD->getInfo()->getOwningModuleID()) Overridden.push_back(SourceID); d3013 9 a3021 10 // The latest visibility directive for a name in a submodule affects all // the directives that come before it. if (VisibilityMacroDirective *VisMD = dyn_cast(MD)) { if (!IsPublic.hasValue()) IsPublic = VisMD->isPublic(); } else if (!IsPublic.hasValue() || IsPublic.getValue()) { // FIXME: If we find an imported macro, we should include its list of // overrides in our export. return MD; d3023 4 d3033 6 d3069 4 a3072 8 llvm::SmallVector Overridden; for (MacroDirective * MD = getFirstPublicSubmoduleMacro(Macro, ModID); MD; MD = getNextPublicSubmoduleMacro(MD, ModID, Overridden)) { // Previous macro's overrides. if (!Overridden.empty()) DataLen += 4 * (1 + Overridden.size()); DataLen += 4; // MacroInfo ID or ModuleID. a3073 3 // Previous macro's overrides. if (!Overridden.empty()) DataLen += 4 * (1 + Overridden.size()); a3098 9 static void emitMacroOverrides(raw_ostream &Out, llvm::ArrayRef Overridden) { if (!Overridden.empty()) { clang::io::Emit32(Out, Overridden.size() | 0x80000000U); for (unsigned I = 0, N = Overridden.size(); I != N; ++I) clang::io::Emit32(Out, Overridden[I]); } } d3126 6 a3131 14 llvm::SmallVector Overridden; for (MacroDirective * MD = getFirstPublicSubmoduleMacro(Macro, ModID); MD; MD = getNextPublicSubmoduleMacro(MD, ModID, Overridden)) { MacroID InfoID = 0; emitMacroOverrides(Out, Overridden); if (DefMacroDirective *DefMD = dyn_cast(MD)) { InfoID = Writer.getMacroID(DefMD->getInfo()); assert(InfoID); clang::io::Emit32(Out, InfoID << 1); } else { assert(isa(MD)); clang::io::Emit32(Out, (ModID << 1) | 1); } a3132 1 emitMacroOverrides(Out, Overridden); d3802 3 a3804 1 llvm::DeleteContainerSeconds(FileDeclIDs); @ 1.1.1.5.2.1 log @Rebase. @ text @a19 1 #include "clang/AST/DeclLookups.h" a24 1 #include "clang/Basic/DiagnosticOptions.h" d27 1 a47 1 #include "llvm/Support/EndianStream.h" a49 1 #include "llvm/Support/OnDiskHashTable.h" d197 9 a205 2 static void addExceptionSpec(ASTWriter &Writer, const FunctionProtoType *T, ASTWriter::RecordDataImpl &Record) { a218 12 } void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { VisitFunctionType(T); Record.push_back(T->getNumParams()); for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Writer.AddTypeRef(T->getParamType(I), Record); Record.push_back(T->isVariadic()); Record.push_back(T->hasTrailingReturn()); Record.push_back(T->getTypeQuals()); Record.push_back(static_cast(T->getRefQualifier())); addExceptionSpec(Writer, T, Record); d404 3 a406 2 for (const auto *I : T->quals()) Writer.AddDeclRef(I, Record); d657 1 a657 2 if (!Name || Name[0] == 0) return; a794 2 RECORD(MODULE_NAME); RECORD(MODULE_MAP_FILE); a858 1 RECORD(OPTIMIZE_PRAGMA_OPTIONS); a1046 26 // Module name if (WritingModule) { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(MODULE_NAME); Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name); } // Module map file if (WritingModule) { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_MAP_FILE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Filename unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); assert(WritingModule->ModuleMap && "missing module map"); SmallString<128> ModuleMap(WritingModule->ModuleMap->getName()); llvm::sys::fs::make_absolute(ModuleMap); RecordData Record; Record.push_back(MODULE_MAP_FILE); Stream.EmitRecordWithBlob(AbbrevCode, Record, ModuleMap.str()); } d1062 1 d1106 1 a1163 1 AddString(HSOpts.ModuleUserBuildPath, Record); d1302 27 d1365 1 a1365 1 SourceMgr.getFileManager().FixupRelativePath(FilePath); a1477 2 typedef unsigned hash_value_type; typedef unsigned offset_type; d1479 1 a1479 1 static hash_value_type ComputeHash(key_type_ref key) { a1488 2 using namespace llvm::support; endian::Writer Writer(Out); d1490 1 a1490 1 Writer.write(KeyLen); d1494 1 a1494 1 Writer.write(DataLen); d1499 1 a1499 3 using namespace llvm::support; endian::Writer LE(Out); LE.write(key.FE->getSize()); d1501 1 a1501 1 LE.write(key.FE->getModificationTime()); d1508 1 a1508 2 using namespace llvm::support; endian::Writer LE(Out); d1517 2 a1518 2 LE.write(Flags); LE.write(Data.NumIncludes); d1521 1 a1521 1 LE.write(Data.ControllingMacroID); d1523 1 a1523 1 LE.write(Writer.getIdentifierRef(Data.ControllingMacro)); d1540 1 a1540 1 LE.write(Offset); d1544 1 a1544 1 LE.write(Writer.getExistingSubmoduleID(Mod)); d1566 1 a1566 1 llvm::OnDiskChainedHashTableGenerator Generator; d1576 4 a1579 4 HeaderFileInfo HFI; if (!HS.tryGetFileInfo(File, HFI) || (HFI.External && Chain) || (HFI.isModuleHeader && !HFI.isCompilingModuleHeader)) a1601 1 using namespace llvm::support; d1604 1 a1604 1 endian::Writer(Out).write(0); a1844 2 typedef unsigned hash_value_type; typedef unsigned offset_type; d1846 1 a1846 1 static hash_value_type ComputeHash(IdentID IdID) { d1859 1 a1859 2 using namespace llvm::support; endian::Writer(Out).write(Key); d1864 1 a1864 2 using namespace llvm::support; endian::Writer(Out).write(Data.MacroDirectivesOffset); d1936 1 a1936 1 llvm::OnDiskChainedHashTableGenerator Generator; a2017 1 Record.push_back(MI->isUsedForHeaderGuard()); a2059 1 using namespace llvm::support; d2062 1 a2062 1 endian::Writer(Out).write(0); d2233 3 a2235 1 for (const auto *I : Context->local_imports()) { d2254 1 a2254 2 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC a2341 1 Record.push_back(Mod->IsExternC); d2624 3 a2626 2 for (const auto *D : DC->decls()) Decls.push_back(std::make_pair(D->getKind(), GetDeclRef(D))); a2724 3 typedef unsigned hash_value_type; typedef unsigned offset_type; d2727 1 a2727 1 static hash_value_type ComputeHash(Selector Sel) { a2733 2 using namespace llvm::support; endian::Writer LE(Out); d2735 1 a2735 1 LE.write(KeyLen); d2745 1 a2745 1 LE.write(DataLen); a2749 2 using namespace llvm::support; endian::Writer LE(Out); d2754 1 a2754 1 LE.write(N); d2758 2 a2759 2 LE.write( Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); a2763 2 using namespace llvm::support; endian::Writer LE(Out); d2765 1 a2765 1 LE.write(Methods.ID); d2785 2 a2786 2 LE.write(NumInstanceMethodsAndBits); LE.write(NumFactoryMethodsAndBits); d2790 1 a2790 1 LE.write(Writer.getDeclID(Method->Method)); d2794 1 a2794 1 LE.write(Writer.getDeclID(Method->Method)); d2815 1 a2815 1 llvm::OnDiskChainedHashTableGenerator Generator; a2862 1 using namespace llvm::support; d2866 1 a2866 1 endian::Writer(Out).write(0); d2974 1 a2974 1 return nullptr; d2984 1 a2984 1 return nullptr; d3000 1 a3000 1 return nullptr; d3023 2 a3024 11 if (DefMacroDirective *DefMD = dyn_cast(MD)) { // Figure out which submodule the macro was originally defined within. SubmoduleID SourceID = DefMD->getInfo()->getOwningModuleID(); if (!SourceID) { SourceLocation DefLoc = DefMD->getInfo()->getDefinitionLoc(); if (DefLoc == MD->getLocation()) SourceID = ThisModID; else SourceID = Writer.inferSubmoduleIDFromLocation(DefLoc); } if (SourceID != OrigModID) a3025 1 } d3046 1 a3046 1 return nullptr; a3059 3 typedef unsigned hash_value_type; typedef unsigned offset_type; d3064 1 a3064 1 static hash_value_type ComputeHash(const IdentifierInfo* II) { d3072 1 a3072 1 MacroDirective *Macro = nullptr; d3101 1 a3101 4 using namespace llvm::support; endian::Writer LE(Out); LE.write(DataLen); d3105 1 a3105 1 LE.write(KeyLen); d3120 1 a3120 3 using namespace llvm::support; endian::Writer LE(Out); LE.write(Overridden.size() | 0x80000000U); d3122 1 a3122 1 LE.write(Overridden[I]); d3128 1 a3128 3 using namespace llvm::support; endian::Writer LE(Out); MacroDirective *Macro = nullptr; d3130 1 a3130 1 LE.write(ID << 1); d3134 1 a3134 1 LE.write((ID << 1) | 0x01); d3137 1 a3137 1 LE.write(Bits); d3146 1 a3146 1 LE.write(Bits); d3149 1 a3149 1 LE.write(Writer.getMacroDirectivesOffset(II)); d3162 1 a3162 1 LE.write(InfoID << 1); d3165 1 a3165 1 LE.write((ModID << 1) | 1); d3169 1 a3169 1 LE.write(0); d3184 1 a3184 1 LE.write(Writer.getDeclID(getMostRecentLocalDecl(*D))); d3223 1 a3223 1 llvm::OnDiskChainedHashTableGenerator Generator; a3252 1 using namespace llvm::support; d3256 1 a3256 1 endian::Writer(Out).write(0); a3310 3 typedef unsigned hash_value_type; typedef unsigned offset_type; d3313 1 a3313 1 hash_value_type ComputeHash(DeclarationName Name) { a3344 2 using namespace llvm::support; endian::Writer LE(Out); d3363 1 a3363 1 LE.write(KeyLen); d3367 1 a3367 1 LE.write(DataLen); d3373 3 a3375 3 using namespace llvm::support; endian::Writer LE(Out); LE.write(Name.getNameKind()); d3378 1 a3378 1 LE.write(Writer.getIdentifierRef(Name.getAsIdentifierInfo())); d3383 1 a3383 1 LE.write(Writer.getSelectorRef(Name.getObjCSelector())); d3388 1 a3388 1 LE.write(Name.getCXXOverloadedOperator()); d3391 1 a3391 1 LE.write(Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); a3404 2 using namespace llvm::support; endian::Writer LE(Out); d3406 1 a3406 1 LE.write(Lookup.size()); d3409 1 a3409 1 LE.write(Writer.GetDeclRef(*I)); a3415 115 template static void visitLocalLookupResults(const DeclContext *ConstDC, bool NeedToReconcileExternalVisibleStorage, Visitor AddLookupResult) { // FIXME: We need to build the lookups table, which is logically const. DeclContext *DC = const_cast(ConstDC); assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table"); SmallVector ExternalNames; for (auto &Lookup : *DC->buildLookup()) { if (Lookup.second.hasExternalDecls() || NeedToReconcileExternalVisibleStorage) { // We don't know for sure what declarations are found by this name, // because the external source might have a different set from the set // that are in the lookup map, and we can't update it now without // risking invalidating our lookup iterator. So add it to a queue to // deal with later. ExternalNames.push_back(Lookup.first); continue; } AddLookupResult(Lookup.first, Lookup.second.getLookupResult()); } // Add the names we needed to defer. Note, this shouldn't add any new decls // to the list we need to serialize: any new declarations we find here should // be imported from an external source. // FIXME: What if the external source isn't an ASTReader? for (const auto &Name : ExternalNames) AddLookupResult(Name, DC->lookup(Name)); } void ASTWriter::AddUpdatedDeclContext(const DeclContext *DC) { if (UpdatedDeclContexts.insert(DC) && WritingAST) { // Ensure we emit all the visible declarations. visitLocalLookupResults(DC, DC->NeedToReconcileExternalVisibleStorage, [&](DeclarationName Name, DeclContext::lookup_const_result Result) { for (auto *Decl : Result) GetDeclRef(Decl); }); } } uint32_t ASTWriter::GenerateNameLookupTable(const DeclContext *DC, llvm::SmallVectorImpl &LookupTable) { assert(!DC->LookupPtr.getInt() && "must call buildLookups first"); llvm::OnDiskChainedHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // Create the on-disk hash table representation. DeclarationName ConstructorName; DeclarationName ConversionName; SmallVector ConstructorDecls; SmallVector ConversionDecls; visitLocalLookupResults(DC, DC->NeedToReconcileExternalVisibleStorage, [&](DeclarationName Name, DeclContext::lookup_result Result) { if (Result.empty()) return; // Different DeclarationName values of certain kinds are mapped to // identical serialized keys, because we don't want to use type // identifiers in the keys (since type ids are local to the module). switch (Name.getNameKind()) { case DeclarationName::CXXConstructorName: // There may be different CXXConstructorName DeclarationName values // in a DeclContext because a UsingDecl that inherits constructors // has the DeclarationName of the inherited constructors. if (!ConstructorName) ConstructorName = Name; ConstructorDecls.append(Result.begin(), Result.end()); return; case DeclarationName::CXXConversionFunctionName: if (!ConversionName) ConversionName = Name; ConversionDecls.append(Result.begin(), Result.end()); return; default: break; } Generator.insert(Name, Result, Trait); }); // Add the constructors. if (!ConstructorDecls.empty()) { Generator.insert(ConstructorName, DeclContext::lookup_result(ConstructorDecls.begin(), ConstructorDecls.end()), Trait); } // Add the conversion functions. if (!ConversionDecls.empty()) { Generator.insert(ConversionName, DeclContext::lookup_result(ConversionDecls.begin(), ConversionDecls.end()), Trait); } // Create the on-disk hash table in a buffer. llvm::raw_svector_ostream Out(LookupTable); // Make sure that no bucket is at offset 0 using namespace llvm::support; endian::Writer(Out).write(0); return Generator.Emit(Out, Trait); } d3446 35 d3483 7 a3489 1 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable); d3510 1 a3510 1 StoredDeclsMap *Map = DC->getLookupPtr(); d3514 14 d3530 7 a3536 1 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable); d3706 1 a3706 1 : GetDeclRef(I->first); a3739 8 /// \brief Write the state of 'pragma clang optimize' at the end of the module. void ASTWriter::WriteOptimizePragmaOptions(Sema &SemaRef) { RecordData Record; SourceLocation PragmaLoc = SemaRef.getOptimizeOffPragmaLocation(); AddSourceLocation(PragmaLoc, Record); Stream.EmitRecord(OPTIMIZE_PRAGMA_OPTIONS, Record); } d3813 2 a3814 2 : Stream(Stream), Context(nullptr), PP(nullptr), Chain(nullptr), WritingModule(nullptr), WritingAST(false), DoneWritingDeclsAndTypes(false), d3861 4 a3864 4 Context = nullptr; PP = nullptr; this->WritingModule = nullptr; d3871 2 a3872 2 for (typename Vector::iterator I = Vec.begin(nullptr, true), E = Vec.end(); I != E; ++I) { d3883 1 a3883 1 bool isModule = WritingModule != nullptr; a3942 9 // If we saw any DeclContext updates before we started writing the AST file, // make sure all visible decls in those DeclContexts are written out. if (!UpdatedDeclContexts.empty()) { auto OldUpdatedDeclContexts = std::move(UpdatedDeclContexts); UpdatedDeclContexts.clear(); for (auto *DC : OldUpdatedDeclContexts) AddUpdatedDeclContext(DC); } d4069 5 a4073 3 for (const auto *I : TU->noload_decls()) { if (!I->isFromASTFile()) NewGlobalDecls.push_back(std::make_pair(I->getKind(), GetDeclRef(I))); a4095 1 // FIXME: Why do we not do this if there's already an update block? d4098 4 a4101 2 if (Record.empty()) Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS)); a4103 12 // Add update records for all mangling numbers and static local numbers. // These aren't really update records, but this is a convenient way of // tagging this rare extra data onto the declarations. for (const auto &Number : Context.MangleNumbers) if (!Number.first->isFromASTFile()) DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER, Number.second)); for (const auto &Number : Context.StaticLocalNumbers) if (!Number.first->isFromASTFile()) DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER, Number.second)); d4127 3 d4141 24 a4190 2 using namespace llvm::support; endian::Writer LE(Out); d4192 1 a4192 1 LE.write(FileName.size()); d4194 8 a4201 8 LE.write((*M)->SLocEntryBaseOffset); LE.write((*M)->BaseIdentifierID); LE.write((*M)->BaseMacroID); LE.write((*M)->BasePreprocessedEntityID); LE.write((*M)->BaseSubmoduleID); LE.write((*M)->BaseSelectorID); LE.write((*M)->BaseDeclID); LE.write((*M)->BaseTypeIndex); a4208 35 RecordData DeclUpdatesOffsetsRecord; // Keep writing types, declarations, and declaration update records // until we've emitted all of them. Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); WriteDeclsBlockAbbrevs(); for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(), E = DeclsToRewrite.end(); I != E; ++I) DeclTypesToEmit.push(const_cast(*I)); do { WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord); while (!DeclTypesToEmit.empty()) { DeclOrType DOT = DeclTypesToEmit.front(); DeclTypesToEmit.pop(); if (DOT.isType()) WriteType(DOT.getType()); else WriteDecl(Context, DOT.getDecl()); } } while (!DeclUpdates.empty()); Stream.ExitBlock(); DoneWritingDeclsAndTypes = true; // These things can only be done once we've written out decls and types. WriteTypeDeclOffsets(); if (!DeclUpdatesOffsetsRecord.empty()) Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord); WriteCXXBaseSpecifiersOffsets(); WriteFileDeclIDsMap(); WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); WriteComments(); d4216 2 d4220 2 d4287 5 a4291 2 for (auto *DC : UpdatedDeclContexts) WriteDeclContextVisibleUpdate(DC); d4295 4 a4298 7 struct ModuleInfo { uint64_t ID; Module *M; ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {} }; llvm::SmallVector Imports; for (const auto *I : Context.local_imports()) { d4300 1 a4300 2 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()], I->getImportedModule())); d4302 9 a4310 20 if (!Imports.empty()) { auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) { return A.ID < B.ID; }; // Sort and deduplicate module IDs. std::sort(Imports.begin(), Imports.end(), Cmp); Imports.erase(std::unique(Imports.begin(), Imports.end(), Cmp), Imports.end()); RecordData ImportedModules; for (const auto &Import : Imports) { ImportedModules.push_back(Import.ID); // FIXME: If the module has macros imported then later has declarations // imported, this location won't be the right one as a location for the // declaration imports. AddSourceLocation(Import.M->MacroVisibilityLoc, ImportedModules); } d4315 1 a4320 2 if(!WritingModule) WriteOptimizePragmaOptions(SemaRef); d4332 8 a4339 9 void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { if (DeclUpdates.empty()) return; DeclUpdateMap LocalUpdates; LocalUpdates.swap(DeclUpdates); for (auto &DeclUpdate : LocalUpdates) { const Decl *D = DeclUpdate.first; d4341 1 a4341 1 continue; // The decl will be written completely,no need to store updates. d4343 3 a4345 7 bool HasUpdatedBody = false; RecordData Record; for (auto &Update : DeclUpdate.second) { DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind(); Record.push_back(Kind); switch (Kind) { d4349 2 a4350 2 assert(Update.getDecl() && "no decl to add?"); Record.push_back(GetDeclRef(Update.getDecl())); d4354 2 a4355 61 AddSourceLocation(Update.getLoc(), Record); break; case UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION: // An updated body is emitted last, so that the reader doesn't need // to skip over the lazy body to reach statements for other records. Record.pop_back(); HasUpdatedBody = true; break; case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: { auto *RD = cast(D); AddUpdatedDeclContext(RD->getPrimaryContext()); AddCXXDefinitionData(RD, Record); Record.push_back(WriteDeclContextLexicalBlock( *Context, const_cast(RD))); // This state is sometimes updated by template instantiation, when we // switch from the specialization referring to the template declaration // to it referring to the template definition. if (auto *MSInfo = RD->getMemberSpecializationInfo()) { Record.push_back(MSInfo->getTemplateSpecializationKind()); AddSourceLocation(MSInfo->getPointOfInstantiation(), Record); } else { auto *Spec = cast(RD); Record.push_back(Spec->getTemplateSpecializationKind()); AddSourceLocation(Spec->getPointOfInstantiation(), Record); // The instantiation might have been resolved to a partial // specialization. If so, record which one. auto From = Spec->getInstantiatedFrom(); if (auto PartialSpec = From.dyn_cast()) { Record.push_back(true); AddDeclRef(PartialSpec, Record); AddTemplateArgumentList(&Spec->getTemplateInstantiationArgs(), Record); } else { Record.push_back(false); } } Record.push_back(RD->getTagKind()); AddSourceLocation(RD->getLocation(), Record); AddSourceLocation(RD->getLocStart(), Record); AddSourceLocation(RD->getRBraceLoc(), Record); // Instantiation may change attributes; write them all out afresh. Record.push_back(D->hasAttrs()); if (Record.back()) WriteAttributes(ArrayRef(D->getAttrs().begin(), D->getAttrs().size()), Record); // FIXME: Ensure we don't get here for explicit instantiations. break; } case UPD_CXX_RESOLVED_EXCEPTION_SPEC: addExceptionSpec( *this, cast(D)->getType()->castAs(), Record); d4359 3 a4361 9 Record.push_back(GetOrCreateTypeID(Update.getType())); break; case UPD_DECL_MARKED_USED: break; case UPD_MANGLING_NUMBER: case UPD_STATIC_LOCAL_NUMBER: Record.push_back(Update.getNumber()); d4365 2 d4368 3 a4370 7 if (HasUpdatedBody) { const FunctionDecl *Def = cast(D); Record.push_back(UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION); Record.push_back(Def->isInlined()); AddSourceLocation(Def->getInnerLocStart(), Record); AddFunctionDefinition(Def, Record); } d4372 6 a4377 2 OffsetsRecord.push_back(GetDeclRef(D)); OffsetsRecord.push_back(Stream.GetCurrentBitNo()); d4379 2 a4380 1 Stream.EmitRecord(DECL_UPDATES, Record); d4382 2 a4383 2 // Flush any statements that were written as part of this update record. FlushStmts(); d4385 2 a4386 2 // Flush C++ base specifiers, if there are any. FlushCXXBaseSpecifiers(); d4388 2 d4435 1 a4435 1 if (!II) d4448 1 a4448 1 if (!MI || MI->isBuiltinMacro()) d4461 1 a4461 1 if (!MI || MI->isBuiltinMacro()) d4478 1 a4478 1 if (Sel.getAsOpaquePtr() == nullptr) { d4556 1 a4556 1 if (!TInfo) { d4624 2 a4625 2 if (!D) { d4652 1 a4652 1 if (!D) d4685 1 a4685 1 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); d5105 2 a5106 1 auto &Data = D->data(); a5131 1 Record.push_back(Data.DeclaredNonTrivialSpecialMembers); d5164 1 a5164 1 auto &Lambda = D->getLambdaData(); d5174 1 a5174 1 const LambdaCapture &Capture = Lambda.Captures[I]; d5184 1 a5184 1 Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr; d5274 1 a5274 4 assert(isTemplateInstantiation(RD->getTemplateSpecializationKind()) && "completed a tag from another module but not by instantiation?"); DeclUpdates[RD].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_CLASS_DEFINITION)); d5304 3 a5306 1 DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D)); d5317 3 a5319 2 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); d5330 3 a5332 2 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); d5343 3 a5345 11 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); } void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) { assert(!WritingAST && "Already writing the AST!"); FD = FD->getCanonicalDecl(); if (!FD->isFromASTFile()) return; // Not a function declared in PCH and defined outside. DeclUpdates[FD].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC); d5354 3 a5356 1 DeclUpdates[FD].push_back(DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType)); a5368 11 void ASTWriter::FunctionDefinitionInstantiated(const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Since the actual instantiation is delayed, this really means that we need // to update the instantiation location. DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION)); } d5376 4 a5379 3 DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER, D->getMemberSpecializationInfo()->getPointOfInstantiation())); d5413 2 a5414 1 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_USED)); @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @a19 1 #include "clang/AST/DeclLookups.h" a24 1 #include "clang/Basic/DiagnosticOptions.h" d27 1 a47 1 #include "llvm/Support/EndianStream.h" a49 1 #include "llvm/Support/OnDiskHashTable.h" d197 9 a205 2 static void addExceptionSpec(ASTWriter &Writer, const FunctionProtoType *T, ASTWriter::RecordDataImpl &Record) { a218 12 } void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { VisitFunctionType(T); Record.push_back(T->getNumParams()); for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Writer.AddTypeRef(T->getParamType(I), Record); Record.push_back(T->isVariadic()); Record.push_back(T->hasTrailingReturn()); Record.push_back(T->getTypeQuals()); Record.push_back(static_cast(T->getRefQualifier())); addExceptionSpec(Writer, T, Record); d404 3 a406 2 for (const auto *I : T->quals()) Writer.AddDeclRef(I, Record); d657 1 a657 2 if (!Name || Name[0] == 0) return; a794 2 RECORD(MODULE_NAME); RECORD(MODULE_MAP_FILE); a858 1 RECORD(OPTIMIZE_PRAGMA_OPTIONS); a1046 26 // Module name if (WritingModule) { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(MODULE_NAME); Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name); } // Module map file if (WritingModule) { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_MAP_FILE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Filename unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); assert(WritingModule->ModuleMap && "missing module map"); SmallString<128> ModuleMap(WritingModule->ModuleMap->getName()); llvm::sys::fs::make_absolute(ModuleMap); RecordData Record; Record.push_back(MODULE_MAP_FILE); Stream.EmitRecordWithBlob(AbbrevCode, Record, ModuleMap.str()); } d1062 1 d1106 1 a1163 1 AddString(HSOpts.ModuleUserBuildPath, Record); d1302 27 d1365 1 a1365 1 SourceMgr.getFileManager().FixupRelativePath(FilePath); a1477 2 typedef unsigned hash_value_type; typedef unsigned offset_type; d1479 1 a1479 1 static hash_value_type ComputeHash(key_type_ref key) { a1488 2 using namespace llvm::support; endian::Writer Writer(Out); d1490 1 a1490 1 Writer.write(KeyLen); d1494 1 a1494 1 Writer.write(DataLen); d1499 1 a1499 3 using namespace llvm::support; endian::Writer LE(Out); LE.write(key.FE->getSize()); d1501 1 a1501 1 LE.write(key.FE->getModificationTime()); d1508 1 a1508 2 using namespace llvm::support; endian::Writer LE(Out); d1517 2 a1518 2 LE.write(Flags); LE.write(Data.NumIncludes); d1521 1 a1521 1 LE.write(Data.ControllingMacroID); d1523 1 a1523 1 LE.write(Writer.getIdentifierRef(Data.ControllingMacro)); d1540 1 a1540 1 LE.write(Offset); d1544 1 a1544 1 LE.write(Writer.getExistingSubmoduleID(Mod)); d1566 1 a1566 1 llvm::OnDiskChainedHashTableGenerator Generator; d1576 4 a1579 4 HeaderFileInfo HFI; if (!HS.tryGetFileInfo(File, HFI) || (HFI.External && Chain) || (HFI.isModuleHeader && !HFI.isCompilingModuleHeader)) a1601 1 using namespace llvm::support; d1604 1 a1604 1 endian::Writer(Out).write(0); a1844 2 typedef unsigned hash_value_type; typedef unsigned offset_type; d1846 1 a1846 1 static hash_value_type ComputeHash(IdentID IdID) { d1859 1 a1859 2 using namespace llvm::support; endian::Writer(Out).write(Key); d1864 1 a1864 2 using namespace llvm::support; endian::Writer(Out).write(Data.MacroDirectivesOffset); d1936 1 a1936 1 llvm::OnDiskChainedHashTableGenerator Generator; a2017 1 Record.push_back(MI->isUsedForHeaderGuard()); a2059 1 using namespace llvm::support; d2062 1 a2062 1 endian::Writer(Out).write(0); d2233 3 a2235 1 for (const auto *I : Context->local_imports()) { d2254 1 a2254 2 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC a2341 1 Record.push_back(Mod->IsExternC); d2624 3 a2626 2 for (const auto *D : DC->decls()) Decls.push_back(std::make_pair(D->getKind(), GetDeclRef(D))); a2724 3 typedef unsigned hash_value_type; typedef unsigned offset_type; d2727 1 a2727 1 static hash_value_type ComputeHash(Selector Sel) { a2733 2 using namespace llvm::support; endian::Writer LE(Out); d2735 1 a2735 1 LE.write(KeyLen); d2745 1 a2745 1 LE.write(DataLen); a2749 2 using namespace llvm::support; endian::Writer LE(Out); d2754 1 a2754 1 LE.write(N); d2758 2 a2759 2 LE.write( Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); a2763 2 using namespace llvm::support; endian::Writer LE(Out); d2765 1 a2765 1 LE.write(Methods.ID); d2785 2 a2786 2 LE.write(NumInstanceMethodsAndBits); LE.write(NumFactoryMethodsAndBits); d2790 1 a2790 1 LE.write(Writer.getDeclID(Method->Method)); d2794 1 a2794 1 LE.write(Writer.getDeclID(Method->Method)); d2815 1 a2815 1 llvm::OnDiskChainedHashTableGenerator Generator; a2862 1 using namespace llvm::support; d2866 1 a2866 1 endian::Writer(Out).write(0); d2974 1 a2974 1 return nullptr; d2984 1 a2984 1 return nullptr; d3000 1 a3000 1 return nullptr; d3023 2 a3024 11 if (DefMacroDirective *DefMD = dyn_cast(MD)) { // Figure out which submodule the macro was originally defined within. SubmoduleID SourceID = DefMD->getInfo()->getOwningModuleID(); if (!SourceID) { SourceLocation DefLoc = DefMD->getInfo()->getDefinitionLoc(); if (DefLoc == MD->getLocation()) SourceID = ThisModID; else SourceID = Writer.inferSubmoduleIDFromLocation(DefLoc); } if (SourceID != OrigModID) a3025 1 } d3046 1 a3046 1 return nullptr; a3059 3 typedef unsigned hash_value_type; typedef unsigned offset_type; d3064 1 a3064 1 static hash_value_type ComputeHash(const IdentifierInfo* II) { d3072 1 a3072 1 MacroDirective *Macro = nullptr; d3101 1 a3101 4 using namespace llvm::support; endian::Writer LE(Out); LE.write(DataLen); d3105 1 a3105 1 LE.write(KeyLen); d3120 1 a3120 3 using namespace llvm::support; endian::Writer LE(Out); LE.write(Overridden.size() | 0x80000000U); d3122 1 a3122 1 LE.write(Overridden[I]); d3128 1 a3128 3 using namespace llvm::support; endian::Writer LE(Out); MacroDirective *Macro = nullptr; d3130 1 a3130 1 LE.write(ID << 1); d3134 1 a3134 1 LE.write((ID << 1) | 0x01); d3137 1 a3137 1 LE.write(Bits); d3146 1 a3146 1 LE.write(Bits); d3149 1 a3149 1 LE.write(Writer.getMacroDirectivesOffset(II)); d3162 1 a3162 1 LE.write(InfoID << 1); d3165 1 a3165 1 LE.write((ModID << 1) | 1); d3169 1 a3169 1 LE.write(0); d3184 1 a3184 1 LE.write(Writer.getDeclID(getMostRecentLocalDecl(*D))); d3223 1 a3223 1 llvm::OnDiskChainedHashTableGenerator Generator; a3252 1 using namespace llvm::support; d3256 1 a3256 1 endian::Writer(Out).write(0); a3310 3 typedef unsigned hash_value_type; typedef unsigned offset_type; d3313 1 a3313 1 hash_value_type ComputeHash(DeclarationName Name) { a3344 2 using namespace llvm::support; endian::Writer LE(Out); d3363 1 a3363 1 LE.write(KeyLen); d3367 1 a3367 1 LE.write(DataLen); d3373 3 a3375 3 using namespace llvm::support; endian::Writer LE(Out); LE.write(Name.getNameKind()); d3378 1 a3378 1 LE.write(Writer.getIdentifierRef(Name.getAsIdentifierInfo())); d3383 1 a3383 1 LE.write(Writer.getSelectorRef(Name.getObjCSelector())); d3388 1 a3388 1 LE.write(Name.getCXXOverloadedOperator()); d3391 1 a3391 1 LE.write(Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); a3404 2 using namespace llvm::support; endian::Writer LE(Out); d3406 1 a3406 1 LE.write(Lookup.size()); d3409 1 a3409 1 LE.write(Writer.GetDeclRef(*I)); a3415 115 template static void visitLocalLookupResults(const DeclContext *ConstDC, bool NeedToReconcileExternalVisibleStorage, Visitor AddLookupResult) { // FIXME: We need to build the lookups table, which is logically const. DeclContext *DC = const_cast(ConstDC); assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table"); SmallVector ExternalNames; for (auto &Lookup : *DC->buildLookup()) { if (Lookup.second.hasExternalDecls() || NeedToReconcileExternalVisibleStorage) { // We don't know for sure what declarations are found by this name, // because the external source might have a different set from the set // that are in the lookup map, and we can't update it now without // risking invalidating our lookup iterator. So add it to a queue to // deal with later. ExternalNames.push_back(Lookup.first); continue; } AddLookupResult(Lookup.first, Lookup.second.getLookupResult()); } // Add the names we needed to defer. Note, this shouldn't add any new decls // to the list we need to serialize: any new declarations we find here should // be imported from an external source. // FIXME: What if the external source isn't an ASTReader? for (const auto &Name : ExternalNames) AddLookupResult(Name, DC->lookup(Name)); } void ASTWriter::AddUpdatedDeclContext(const DeclContext *DC) { if (UpdatedDeclContexts.insert(DC) && WritingAST) { // Ensure we emit all the visible declarations. visitLocalLookupResults(DC, DC->NeedToReconcileExternalVisibleStorage, [&](DeclarationName Name, DeclContext::lookup_const_result Result) { for (auto *Decl : Result) GetDeclRef(Decl); }); } } uint32_t ASTWriter::GenerateNameLookupTable(const DeclContext *DC, llvm::SmallVectorImpl &LookupTable) { assert(!DC->LookupPtr.getInt() && "must call buildLookups first"); llvm::OnDiskChainedHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // Create the on-disk hash table representation. DeclarationName ConstructorName; DeclarationName ConversionName; SmallVector ConstructorDecls; SmallVector ConversionDecls; visitLocalLookupResults(DC, DC->NeedToReconcileExternalVisibleStorage, [&](DeclarationName Name, DeclContext::lookup_result Result) { if (Result.empty()) return; // Different DeclarationName values of certain kinds are mapped to // identical serialized keys, because we don't want to use type // identifiers in the keys (since type ids are local to the module). switch (Name.getNameKind()) { case DeclarationName::CXXConstructorName: // There may be different CXXConstructorName DeclarationName values // in a DeclContext because a UsingDecl that inherits constructors // has the DeclarationName of the inherited constructors. if (!ConstructorName) ConstructorName = Name; ConstructorDecls.append(Result.begin(), Result.end()); return; case DeclarationName::CXXConversionFunctionName: if (!ConversionName) ConversionName = Name; ConversionDecls.append(Result.begin(), Result.end()); return; default: break; } Generator.insert(Name, Result, Trait); }); // Add the constructors. if (!ConstructorDecls.empty()) { Generator.insert(ConstructorName, DeclContext::lookup_result(ConstructorDecls.begin(), ConstructorDecls.end()), Trait); } // Add the conversion functions. if (!ConversionDecls.empty()) { Generator.insert(ConversionName, DeclContext::lookup_result(ConversionDecls.begin(), ConversionDecls.end()), Trait); } // Create the on-disk hash table in a buffer. llvm::raw_svector_ostream Out(LookupTable); // Make sure that no bucket is at offset 0 using namespace llvm::support; endian::Writer(Out).write(0); return Generator.Emit(Out, Trait); } d3446 35 d3483 7 a3489 1 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable); d3510 1 a3510 1 StoredDeclsMap *Map = DC->getLookupPtr(); d3514 14 d3530 7 a3536 1 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable); d3706 1 a3706 1 : GetDeclRef(I->first); a3739 8 /// \brief Write the state of 'pragma clang optimize' at the end of the module. void ASTWriter::WriteOptimizePragmaOptions(Sema &SemaRef) { RecordData Record; SourceLocation PragmaLoc = SemaRef.getOptimizeOffPragmaLocation(); AddSourceLocation(PragmaLoc, Record); Stream.EmitRecord(OPTIMIZE_PRAGMA_OPTIONS, Record); } d3813 2 a3814 2 : Stream(Stream), Context(nullptr), PP(nullptr), Chain(nullptr), WritingModule(nullptr), WritingAST(false), DoneWritingDeclsAndTypes(false), d3861 4 a3864 4 Context = nullptr; PP = nullptr; this->WritingModule = nullptr; d3871 2 a3872 2 for (typename Vector::iterator I = Vec.begin(nullptr, true), E = Vec.end(); I != E; ++I) { d3883 1 a3883 1 bool isModule = WritingModule != nullptr; a3942 9 // If we saw any DeclContext updates before we started writing the AST file, // make sure all visible decls in those DeclContexts are written out. if (!UpdatedDeclContexts.empty()) { auto OldUpdatedDeclContexts = std::move(UpdatedDeclContexts); UpdatedDeclContexts.clear(); for (auto *DC : OldUpdatedDeclContexts) AddUpdatedDeclContext(DC); } d4069 5 a4073 3 for (const auto *I : TU->noload_decls()) { if (!I->isFromASTFile()) NewGlobalDecls.push_back(std::make_pair(I->getKind(), GetDeclRef(I))); a4095 1 // FIXME: Why do we not do this if there's already an update block? d4098 4 a4101 2 if (Record.empty()) Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS)); a4103 12 // Add update records for all mangling numbers and static local numbers. // These aren't really update records, but this is a convenient way of // tagging this rare extra data onto the declarations. for (const auto &Number : Context.MangleNumbers) if (!Number.first->isFromASTFile()) DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER, Number.second)); for (const auto &Number : Context.StaticLocalNumbers) if (!Number.first->isFromASTFile()) DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER, Number.second)); d4127 3 d4141 24 a4190 2 using namespace llvm::support; endian::Writer LE(Out); d4192 1 a4192 1 LE.write(FileName.size()); d4194 8 a4201 8 LE.write((*M)->SLocEntryBaseOffset); LE.write((*M)->BaseIdentifierID); LE.write((*M)->BaseMacroID); LE.write((*M)->BasePreprocessedEntityID); LE.write((*M)->BaseSubmoduleID); LE.write((*M)->BaseSelectorID); LE.write((*M)->BaseDeclID); LE.write((*M)->BaseTypeIndex); a4208 35 RecordData DeclUpdatesOffsetsRecord; // Keep writing types, declarations, and declaration update records // until we've emitted all of them. Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); WriteDeclsBlockAbbrevs(); for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(), E = DeclsToRewrite.end(); I != E; ++I) DeclTypesToEmit.push(const_cast(*I)); do { WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord); while (!DeclTypesToEmit.empty()) { DeclOrType DOT = DeclTypesToEmit.front(); DeclTypesToEmit.pop(); if (DOT.isType()) WriteType(DOT.getType()); else WriteDecl(Context, DOT.getDecl()); } } while (!DeclUpdates.empty()); Stream.ExitBlock(); DoneWritingDeclsAndTypes = true; // These things can only be done once we've written out decls and types. WriteTypeDeclOffsets(); if (!DeclUpdatesOffsetsRecord.empty()) Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord); WriteCXXBaseSpecifiersOffsets(); WriteFileDeclIDsMap(); WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); WriteComments(); d4216 2 d4220 2 d4287 5 a4291 2 for (auto *DC : UpdatedDeclContexts) WriteDeclContextVisibleUpdate(DC); d4295 4 a4298 7 struct ModuleInfo { uint64_t ID; Module *M; ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {} }; llvm::SmallVector Imports; for (const auto *I : Context.local_imports()) { d4300 1 a4300 2 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()], I->getImportedModule())); d4302 9 a4310 20 if (!Imports.empty()) { auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) { return A.ID < B.ID; }; // Sort and deduplicate module IDs. std::sort(Imports.begin(), Imports.end(), Cmp); Imports.erase(std::unique(Imports.begin(), Imports.end(), Cmp), Imports.end()); RecordData ImportedModules; for (const auto &Import : Imports) { ImportedModules.push_back(Import.ID); // FIXME: If the module has macros imported then later has declarations // imported, this location won't be the right one as a location for the // declaration imports. AddSourceLocation(Import.M->MacroVisibilityLoc, ImportedModules); } d4315 1 a4320 2 if(!WritingModule) WriteOptimizePragmaOptions(SemaRef); d4332 8 a4339 9 void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { if (DeclUpdates.empty()) return; DeclUpdateMap LocalUpdates; LocalUpdates.swap(DeclUpdates); for (auto &DeclUpdate : LocalUpdates) { const Decl *D = DeclUpdate.first; d4341 1 a4341 1 continue; // The decl will be written completely,no need to store updates. d4343 3 a4345 7 bool HasUpdatedBody = false; RecordData Record; for (auto &Update : DeclUpdate.second) { DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind(); Record.push_back(Kind); switch (Kind) { d4349 2 a4350 2 assert(Update.getDecl() && "no decl to add?"); Record.push_back(GetDeclRef(Update.getDecl())); d4354 2 a4355 61 AddSourceLocation(Update.getLoc(), Record); break; case UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION: // An updated body is emitted last, so that the reader doesn't need // to skip over the lazy body to reach statements for other records. Record.pop_back(); HasUpdatedBody = true; break; case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: { auto *RD = cast(D); AddUpdatedDeclContext(RD->getPrimaryContext()); AddCXXDefinitionData(RD, Record); Record.push_back(WriteDeclContextLexicalBlock( *Context, const_cast(RD))); // This state is sometimes updated by template instantiation, when we // switch from the specialization referring to the template declaration // to it referring to the template definition. if (auto *MSInfo = RD->getMemberSpecializationInfo()) { Record.push_back(MSInfo->getTemplateSpecializationKind()); AddSourceLocation(MSInfo->getPointOfInstantiation(), Record); } else { auto *Spec = cast(RD); Record.push_back(Spec->getTemplateSpecializationKind()); AddSourceLocation(Spec->getPointOfInstantiation(), Record); // The instantiation might have been resolved to a partial // specialization. If so, record which one. auto From = Spec->getInstantiatedFrom(); if (auto PartialSpec = From.dyn_cast()) { Record.push_back(true); AddDeclRef(PartialSpec, Record); AddTemplateArgumentList(&Spec->getTemplateInstantiationArgs(), Record); } else { Record.push_back(false); } } Record.push_back(RD->getTagKind()); AddSourceLocation(RD->getLocation(), Record); AddSourceLocation(RD->getLocStart(), Record); AddSourceLocation(RD->getRBraceLoc(), Record); // Instantiation may change attributes; write them all out afresh. Record.push_back(D->hasAttrs()); if (Record.back()) WriteAttributes(ArrayRef(D->getAttrs().begin(), D->getAttrs().size()), Record); // FIXME: Ensure we don't get here for explicit instantiations. break; } case UPD_CXX_RESOLVED_EXCEPTION_SPEC: addExceptionSpec( *this, cast(D)->getType()->castAs(), Record); d4359 3 a4361 9 Record.push_back(GetOrCreateTypeID(Update.getType())); break; case UPD_DECL_MARKED_USED: break; case UPD_MANGLING_NUMBER: case UPD_STATIC_LOCAL_NUMBER: Record.push_back(Update.getNumber()); d4365 2 d4368 3 a4370 7 if (HasUpdatedBody) { const FunctionDecl *Def = cast(D); Record.push_back(UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION); Record.push_back(Def->isInlined()); AddSourceLocation(Def->getInnerLocStart(), Record); AddFunctionDefinition(Def, Record); } d4372 6 a4377 2 OffsetsRecord.push_back(GetDeclRef(D)); OffsetsRecord.push_back(Stream.GetCurrentBitNo()); d4379 2 a4380 1 Stream.EmitRecord(DECL_UPDATES, Record); d4382 2 a4383 2 // Flush any statements that were written as part of this update record. FlushStmts(); d4385 2 a4386 2 // Flush C++ base specifiers, if there are any. FlushCXXBaseSpecifiers(); d4388 2 d4435 1 a4435 1 if (!II) d4448 1 a4448 1 if (!MI || MI->isBuiltinMacro()) d4461 1 a4461 1 if (!MI || MI->isBuiltinMacro()) d4478 1 a4478 1 if (Sel.getAsOpaquePtr() == nullptr) { d4556 1 a4556 1 if (!TInfo) { d4624 2 a4625 2 if (!D) { d4652 1 a4652 1 if (!D) d4685 1 a4685 1 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); d5105 2 a5106 1 auto &Data = D->data(); a5131 1 Record.push_back(Data.DeclaredNonTrivialSpecialMembers); d5164 1 a5164 1 auto &Lambda = D->getLambdaData(); d5174 1 a5174 1 const LambdaCapture &Capture = Lambda.Captures[I]; d5184 1 a5184 1 Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr; d5274 1 a5274 4 assert(isTemplateInstantiation(RD->getTemplateSpecializationKind()) && "completed a tag from another module but not by instantiation?"); DeclUpdates[RD].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_CLASS_DEFINITION)); d5304 3 a5306 1 DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D)); d5317 3 a5319 2 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); d5330 3 a5332 2 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); d5343 3 a5345 11 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); } void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) { assert(!WritingAST && "Already writing the AST!"); FD = FD->getCanonicalDecl(); if (!FD->isFromASTFile()) return; // Not a function declared in PCH and defined outside. DeclUpdates[FD].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC); d5354 3 a5356 1 DeclUpdates[FD].push_back(DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType)); a5368 11 void ASTWriter::FunctionDefinitionInstantiated(const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Since the actual instantiation is delayed, this really means that we need // to update the instantiation location. DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION)); } d5376 4 a5379 3 DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER, D->getMemberSpecializationInfo()->getPointOfInstantiation())); d5413 2 a5414 1 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_USED)); @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @a85 2 /// \brief Abbreviation to use for the record, if any. unsigned AbbrevToUse; a192 3 if (C.getHasRegParm() || C.getRegParm() || C.getProducesResult()) AbbrevToUse = 0; d219 3 a221 1 a226 9 Record.push_back(T->getNumParams()); for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Writer.AddTypeRef(T->getParamType(I), Record); if (T->isVariadic() || T->hasTrailingReturn() || T->getTypeQuals() || T->getRefQualifier() || T->getExceptionSpecType() != EST_None) AbbrevToUse = 0; a651 34 void ASTWriter::WriteTypeAbbrevs() { using namespace llvm; BitCodeAbbrev *Abv; // Abbreviation for TYPE_EXT_QUAL Abv = new BitCodeAbbrev(); Abv->Add(BitCodeAbbrevOp(serialization::TYPE_EXT_QUAL)); Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3)); // Quals TypeExtQualAbbrev = Stream.EmitAbbrev(Abv); // Abbreviation for TYPE_FUNCTION_PROTO Abv = new BitCodeAbbrev(); Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO)); // FunctionType Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ReturnType Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn Abv->Add(BitCodeAbbrevOp(0)); // HasRegParm Abv->Add(BitCodeAbbrevOp(0)); // RegParm Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC Abv->Add(BitCodeAbbrevOp(0)); // ProducesResult // FunctionProtoType Abv->Add(BitCodeAbbrevOp(0)); // IsVariadic Abv->Add(BitCodeAbbrevOp(0)); // HasTrailingReturn Abv->Add(BitCodeAbbrevOp(0)); // TypeQuals Abv->Add(BitCodeAbbrevOp(0)); // RefQualifier Abv->Add(BitCodeAbbrevOp(EST_None)); // ExceptionSpec Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumParams Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Params TypeFunctionProtoAbbrev = Stream.EmitAbbrev(Abv); } a686 1 RECORD(STMT_REF_PTR); a713 1 RECORD(EXPR_PAREN_LIST); a754 3 RECORD(STMT_CXX_CATCH); RECORD(STMT_CXX_TRY); RECORD(STMT_CXX_FOR_RANGE); a755 1 RECORD(EXPR_CXX_MEMBER_CALL); a756 1 RECORD(EXPR_CXX_TEMPORARY_OBJECT); d768 2 a772 1 RECORD(EXPR_CXX_DEFAULT_INIT); a783 1 RECORD(EXPR_CXX_EXPRESSION_TRAIT); a785 3 RECORD(EXPR_BINARY_CONDITIONAL_OPERATOR); RECORD(EXPR_TYPE_TRAIT); RECORD(EXPR_ARRAY_TYPE_TRAIT); a787 1 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM); a788 2 RECORD(EXPR_FUNCTION_PARM_PACK); RECORD(EXPR_MATERIALIZE_TEMPORARY); a789 3 RECORD(EXPR_CXX_UUIDOF_EXPR); RECORD(EXPR_CXX_UUIDOF_TYPE); RECORD(EXPR_LAMBDA); d898 1 a899 1 RECORD(TYPE_FUNCTION_PROTO); d906 1 a922 2 RECORD(TYPE_AUTO); RECORD(TYPE_UNARY_TRANSFORM); a923 2 RECORD(TYPE_DECAYED); RECORD(TYPE_ADJUSTED); a924 1 RECORD(DECL_TYPEALIAS); d1076 2 a1077 3 const FileEntry *ModMapFile = PP.getHeaderSearchInfo().getModuleMap(). getModuleMapFileForUniquing(WritingModule); SmallString<128> ModuleMap(ModMapFile->getName()); a1162 3 Record.push_back(DiagOpts.Remarks.size()); for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I) AddString(DiagOpts.Remarks[I], Record); a1902 4 // Re-export any imported directives. if (MD->isImported()) return false; d1980 1 a1980 1 if (auto *DefMD = dyn_cast(MD)) { d1983 1 a1983 1 Record.push_back(DefMD->getOwningModuleID()); d1985 3 a1987 4 } else if (auto *UndefMD = dyn_cast(MD)) { Record.push_back(UndefMD->getOwningModuleID()); } else { auto *VisMD = cast(MD); a1989 7 if (MD->isImported()) { auto Overrides = MD->getOverriddenModules(); Record.push_back(Overrides.size()); for (auto Override : Overrides) Record.push_back(Override); } d2265 1 a2265 1 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/4); d2545 1 a2545 1 Record.push_back((unsigned)I->second.getSeverity()); a2604 1 W.AbbrevToUse = 0; a2610 1 W.AbbrevToUse = TypeExtQualAbbrev; d2623 1 a2623 1 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse); d2989 2 a2990 3 MacroState State; if (getFirstPublicSubmoduleMacro(Macro, State)) d2997 1 a2997 10 enum class SubmoduleMacroState { /// We've seen nothing about this macro. None, /// We've seen a public visibility directive. Public, /// We've either exported a macro for this module or found that the /// module's definition of this macro is private. Done }; typedef llvm::DenseMap MacroState; d3000 6 a3005 3 getFirstPublicSubmoduleMacro(MacroDirective *MD, MacroState &State) { if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD, State)) return NextMD; d3010 2 a3011 1 getNextPublicSubmoduleMacro(MacroDirective *MD, MacroState &State) { d3013 3 a3015 2 getPublicSubmoduleMacro(MD->getPrevious(), State)) return NextMD; d3019 2 a3020 3 /// \brief Traverses the macro directives history and returns the next /// public macro definition or undefinition that has not been found so far. /// d3023 5 d3029 2 a3030 1 MacroState &State) { d3034 2 d3038 3 a3040 14 // Once we hit an ignored macro, we're done: the rest of the chain // will all be ignored macros. if (shouldIgnoreMacro(MD, IsModule, PP)) break; // If this macro was imported, re-export it. if (MD->isImported()) return MD; SubmoduleID ModID = getSubmoduleID(MD); auto &S = State[ModID]; assert(ModID && "found macro in no submodule"); if (S == SubmoduleMacroState::Done) a3041 10 if (auto *VisMD = dyn_cast(MD)) { // The latest visibility directive for a name in a submodule affects all // the directives that come before it. if (S == SubmoduleMacroState::None) S = VisMD->isPublic() ? SubmoduleMacroState::Public : SubmoduleMacroState::Done; } else { S = SubmoduleMacroState::Done; return MD; d3043 4 a3046 18 } return nullptr; } ArrayRef getOverriddenSubmodules(MacroDirective *MD, SmallVectorImpl &ScratchSpace) { assert(!isa(MD) && "only #define and #undef can override"); if (MD->isImported()) return MD->getOverriddenModules(); ScratchSpace.clear(); SubmoduleID ModID = getSubmoduleID(MD); for (MD = MD->getPrevious(); MD; MD = MD->getPrevious()) { if (shouldIgnoreMacro(MD, IsModule, PP)) break; d3051 13 a3063 12 if (MD->isImported()) { if (auto *DefMD = dyn_cast(MD)) { SubmoduleID DefModuleID = DefMD->getInfo()->getOwningModuleID(); assert(DefModuleID && "imported macro has no owning module"); ScratchSpace.push_back(DefModuleID); } else if (auto *UndefMD = dyn_cast(MD)) { // If we override a #undef, we override anything that #undef overrides. // We don't need to override it, since an active #undef doesn't affect // the meaning of a macro. auto Overrides = UndefMD->getOverriddenModules(); ScratchSpace.insert(ScratchSpace.end(), Overrides.begin(), Overrides.end()); d3065 2 d3069 16 a3084 17 // Stop once we leave the original macro's submodule. // // Either this submodule #included another submodule of the same // module or it just happened to be built after the other module. // In the former case, we override the submodule's macro. // // FIXME: In the latter case, we shouldn't do so, but we can't tell // these cases apart. // // FIXME: We can leave this submodule and re-enter it if it #includes a // header within a different submodule of the same module. In such cases // the overrides list will be incomplete. SubmoduleID DirectiveModuleID = getSubmoduleID(MD); if (DirectiveModuleID != ModID) { if (DirectiveModuleID && !MD->isImported()) ScratchSpace.push_back(DirectiveModuleID); break; d3088 1 a3088 4 std::sort(ScratchSpace.begin(), ScratchSpace.end()); ScratchSpace.erase(std::unique(ScratchSpace.begin(), ScratchSpace.end()), ScratchSpace.end()); return ScratchSpace; d3124 8 a3131 4 MacroState State; SmallVector Scratch; for (MacroDirective *MD = getFirstPublicSubmoduleMacro(Macro, State); MD; MD = getNextPublicSubmoduleMacro(MD, State)) { a3132 3 if (unsigned NumOverrides = getOverriddenSubmodules(MD, Scratch).size()) DataLen += 4 * (1 + NumOverrides); d3134 4 a3137 1 DataLen += 4; // 0 terminator. d3144 1 a3144 1 DataLen += 4; d3166 1 a3166 1 ArrayRef Overridden) { d3171 1 a3171 2 for (unsigned I = 0, N = Overridden.size(); I != N; ++I) { assert(Overridden[I] && "zero module ID for override"); a3172 1 } d3204 7 a3210 4 MacroState State; SmallVector Scratch; for (MacroDirective *MD = getFirstPublicSubmoduleMacro(Macro, State); MD; MD = getNextPublicSubmoduleMacro(MD, State)) { d3212 1 a3212 5 // FIXME: If this macro directive was created by #pragma pop_macros, // or if it was created implicitly by resolving conflicting macros, // it may be for a different submodule from the one in the MacroInfo // object. If so, we should write out its owning ModuleID. MacroID InfoID = Writer.getMacroID(DefMD->getInfo()); d3216 2 a3217 5 auto *UndefMD = cast(MD); SubmoduleID Mod = UndefMD->isImported() ? UndefMD->getOwningModuleID() : getSubmoduleID(UndefMD); LE.write((Mod << 1) | 1); a3218 1 emitMacroOverrides(Out, getOverriddenSubmodules(MD, Scratch)); d3220 2 a3221 1 LE.write(0xdeadbeef); d3631 2 d3935 23 a3957 20 : Stream(Stream), Context(nullptr), PP(nullptr), Chain(nullptr), WritingModule(nullptr), WritingAST(false), DoneWritingDeclsAndTypes(false), ASTHasCompilerErrors(false), FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID), FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), NextSubmoduleID(FirstSubmoduleID), FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), NumVisibleDeclContexts(0), NextCXXBaseSpecifiersID(1), TypeExtQualAbbrev(0), TypeFunctionProtoAbbrev(0), DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0), DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0), DeclRecordAbbrev(0), DeclTypedefAbbrev(0), DeclVarAbbrev(0), DeclFieldAbbrev(0), DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0), DeclCXXMethodAbbrev(0), DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0), IntegerLiteralAbbrev(0), ExprImplicitCastAbbrev(0) {} d4329 2 a4330 3 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, /*bits for abbreviations*/5); WriteTypeAbbrevs(); WriteDeclAbbrevs(); d4517 5 a4521 1 case UPD_CXX_ADDED_FUNCTION_DEFINITION: a4527 4 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: AddSourceLocation(Update.getLoc(), Record); break; d4597 1 a4597 1 Record.push_back(UPD_CXX_ADDED_FUNCTION_DEFINITION); a4600 2 if (auto *DD = dyn_cast(Def)) Record.push_back(GetDeclRef(DD->getOperatorDelete())); d5195 3 a5197 2 for (const auto &P : Arg.pack_elements()) AddTemplateArgument(P, Record); d5593 3 a5595 2 // Implicit function decl from a PCH was defined. DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); d5603 2 d5606 1 a5606 1 DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a53 1 #include "llvm/Support/Process.h" a864 1 RECORD(SIGNATURE); a1058 15 /// \brief Prepares a path for being written to an AST file by converting it /// to an absolute path and removing nested './'s. /// /// \return \c true if the path was changed. bool cleanPathForOutput(FileManager &FileMgr, SmallVectorImpl &Path) { bool Changed = false; if (!llvm::sys::path::is_absolute(StringRef(Path.data(), Path.size()))) { llvm::sys::fs::make_absolute(Path); Changed = true; } return Changed | FileMgr.removeDotPaths(Path); } d1064 2 a1065 2 /// \param BaseDir When non-NULL, the PCH file is a relocatable AST file and /// the returned filename will be adjusted by this root directory. d1070 1 a1070 1 adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir) { d1073 1 a1073 1 if (BaseDir.empty()) d1078 2 a1079 2 for (; Filename[Pos] && Pos < BaseDir.size(); ++Pos) if (Filename[Pos] != BaseDir[Pos]) d1086 4 a1089 14 // If there's not a path separator at the end of the base directory nor // immediately after it, then this isn't within the base directory. if (!llvm::sys::path::is_separator(Filename[Pos])) { if (!llvm::sys::path::is_separator(BaseDir.back())) return Filename; } else { // If the file name has a '/' at the current position, skip over the '/'. // We distinguish relative paths from absolute paths by the // absence of '/' at the beginning of relative paths. // // FIXME: This is wrong. We distinguish them by asking if the path is // absolute, which isn't the same thing. And there might be multiple '/'s // in a row. Use a better mechanism to indicate whether we have emitted an // absolute or relative path. a1090 1 } a1094 8 static ASTFileSignature getSignature() { while (1) { if (ASTFileSignature S = llvm::sys::Process::GetRandomNumber()) return S; // Rely on GetRandomNumber to eventually return non-zero... } } a1118 2 assert((!WritingModule || isysroot.empty()) && "writing module as a relocatable PCH?"); d1124 1 a1124 5 // Signature Record.clear(); Record.push_back(getSignature()); Stream.EmitRecord(SIGNATURE, Record); a1125 1 // Module name d1135 2 a1136 2 if (WritingModule && WritingModule->Directory) { // Module directory. d1138 2 a1139 2 Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory d1141 5 d1147 2 a1148 33 Record.push_back(MODULE_DIRECTORY); SmallString<128> BaseDir(WritingModule->Directory->getName()); cleanPathForOutput(Context.getSourceManager().getFileManager(), BaseDir); Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir); // Write out all other paths relative to the base directory if possible. BaseDirectory.assign(BaseDir.begin(), BaseDir.end()); } else if (!isysroot.empty()) { // Write out paths relative to the sysroot if possible. BaseDirectory = isysroot; } // Module map file if (WritingModule) { Record.clear(); auto &Map = PP.getHeaderSearchInfo().getModuleMap(); // Primary module map file. AddPath(Map.getModuleMapFileForUniquing(WritingModule)->getName(), Record); // Additional module map files. if (auto *AdditionalModMaps = Map.getAdditionalModuleMapFiles(WritingModule)) { Record.push_back(AdditionalModMaps->size()); for (const FileEntry *F : *AdditionalModMaps) AddPath(F->getName(), Record); } else { Record.push_back(0); } Stream.EmitRecord(MODULE_MAP_FILE, Record); d1166 3 a1168 2 Record.push_back((*M)->Signature); AddPath((*M)->FileName, Record); d1180 2 a1181 3 #include "clang/Basic/LangOptions.def" #define SANITIZER(NAME, ID) \ Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID)); d1315 7 d1325 1 a1325 1 EmitRecordWithPath(FileAbbrevCode, Record, MainFile->getName()); d1351 1 d1367 1 d1438 17 a1454 2 EmitRecordWithPath(IFAbbrevCode, Record, Entry.File->getName()); } a1563 3 // // FIXME: Using the mtime here will cause problems for explicit module // imports. d1644 1 a1644 1 void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) { d1668 1 a1668 1 // Massage the file path into an appropriate form. d1670 6 a1675 5 SmallString<128> FilenameTmp(Filename); if (PreparePathForOutput(FilenameTmp)) { // If we performed any translation on the file name at all, we need to // save this string, since the generator will refer to it later. Filename = strdup(FilenameTmp.c_str()); d1678 1 a1678 1 d1728 2 a1729 1 const Preprocessor &PP) { d1878 1 a1878 1 // Emit the file names. d1880 9 a1888 2 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) AddPath(LineTable.getFilename(I), Record); d2347 1 a2347 1 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/5); a2397 5 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TEXTUAL_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); a2402 5 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_TEXTUAL_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); d2474 1 a2474 1 d2476 8 a2483 13 struct { unsigned RecordKind; unsigned Abbrev; Module::HeaderKind HeaderKind; } HeaderLists[] = { {SUBMODULE_HEADER, HeaderAbbrev, Module::HK_Normal}, {SUBMODULE_TEXTUAL_HEADER, TextualHeaderAbbrev, Module::HK_Textual}, {SUBMODULE_PRIVATE_HEADER, PrivateHeaderAbbrev, Module::HK_Private}, {SUBMODULE_PRIVATE_TEXTUAL_HEADER, PrivateTextualHeaderAbbrev, Module::HK_PrivateTextual}, {SUBMODULE_EXCLUDED_HEADER, ExcludedHeaderAbbrev, Module::HK_Excluded} }; for (auto &HL : HeaderLists) { d2485 3 a2487 3 Record.push_back(HL.RecordKind); for (auto &H : Mod->Headers[HL.HeaderKind]) Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten); d2489 10 a2498 4 // Emit the top headers. { auto TopHeaders = Mod->getTopHeaders(PP->getFileManager()); d2501 2 a2502 2 for (auto *H : TopHeaders) Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, H->getName()); d2510 1 a2510 1 assert(ImportedID && "Unknown submodule!"); d2850 1 a2850 1 if (Method->getMethod()) d2854 1 a2854 1 if (Method->getMethod()) d2884 1 a2884 1 if (Method->getMethod()) d2890 1 a2890 1 if (Method->getMethod()) d2895 2 a2896 5 unsigned InstanceHasMoreThanOneDeclBit = Methods.Instance.hasMoreThanOneDecl(); unsigned FullInstanceBits = (NumInstanceMethods << 3) | (InstanceHasMoreThanOneDeclBit << 2) | InstanceBits; d2899 3 a2901 7 unsigned FactoryHasMoreThanOneDeclBit = Methods.Factory.hasMoreThanOneDecl(); unsigned FullFactoryBits = (NumFactoryMethods << 3) | (FactoryHasMoreThanOneDeclBit << 2) | FactoryBits; LE.write(FullInstanceBits); LE.write(FullFactoryBits); d2904 2 a2905 2 if (Method->getMethod()) LE.write(Writer.getDeclID(Method->getMethod())); d2908 2 a2909 2 if (Method->getMethod()) LE.write(Writer.getDeclID(Method->getMethod())); d2955 3 a2957 3 for (ObjCMethodList *M = &Data.Instance; !changed && M && M->getMethod(); M = M->getNext()) { if (!M->getMethod()->isFromASTFile()) d2960 1 a2960 1 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->getMethod(); d2962 1 a2962 1 if (!M->getMethod()->isFromASTFile()) d2967 1 a2967 1 } else if (Data.Instance.getMethod() || Data.Factory.getMethod()) { a3471 25 /// Determine the declaration that should be put into the name lookup table to /// represent the given declaration in this module. This is usually D itself, /// but if D was imported and merged into a local declaration, we want the most /// recent local declaration instead. The chosen declaration will be the most /// recent declaration in any module that imports this one. static NamedDecl *getDeclForLocalLookup(NamedDecl *D) { if (!D->isFromASTFile()) return D; if (Decl *Redecl = D->getPreviousDecl()) { // For Redeclarable decls, a prior declaration might be local. for (; Redecl; Redecl = Redecl->getPreviousDecl()) if (!Redecl->isFromASTFile()) return cast(Redecl); } else if (Decl *First = D->getCanonicalDecl()) { // For Mergeable decls, the first decl might be local. if (!First->isFromASTFile()) return cast(First); } // All declarations are imported. Our most recent declaration will also be // the most recent one in anyone who imports us. return D; } d3589 1 a3589 1 LE.write(Writer.GetDeclRef(getDeclForLocalLookup(*I))); d3629 1 a3629 1 if (UpdatedDeclContexts.insert(DC).second && WritingAST) { d3635 1 a3635 1 GetDeclRef(getDeclForLocalLookup(Decl)); a3831 2 // FIXME: Do we need to do this for the first declaration from each // redeclaration chain that was merged into this one? a4016 31 bool ASTWriter::PreparePathForOutput(SmallVectorImpl &Path) { assert(Context && "should have context when outputting path"); bool Changed = cleanPathForOutput(Context->getSourceManager().getFileManager(), Path); // Remove a prefix to make the path relative, if relevant. const char *PathBegin = Path.data(); const char *PathPtr = adjustFilenameForRelocatableAST(PathBegin, BaseDirectory); if (PathPtr != PathBegin) { Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin)); Changed = true; } return Changed; } void ASTWriter::AddPath(StringRef Path, RecordDataImpl &Record) { SmallString<128> FilePath(Path); PreparePathForOutput(FilePath); AddString(FilePath, Record); } void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataImpl &Record, StringRef Path) { SmallString<128> FilePath(Path); PreparePathForOutput(FilePath); Stream.EmitRecordWithBlob(Abbrev, Record, FilePath); } a4100 1 this->BaseDirectory.clear(); a4249 5 // Build a record containing all of the UnusedLocalTypedefNameCandidates. RecordData UnusedLocalTypedefNameCandidates; for (const TypedefNameDecl *TD : SemaRef.UnusedLocalTypedefNameCandidates) AddDeclRef(TD, UnusedLocalTypedefNameCandidates); d4416 3 a4418 1 for (ModuleFile *M : Chain->ModuleMgr) { d4421 1 a4421 1 StringRef FileName = M->FileName; d4424 8 a4431 24 // Note: if a base ID was uint max, it would not be possible to load // another module after it or have more than one entity inside it. uint32_t None = std::numeric_limits::max(); auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) { assert(BaseID < std::numeric_limits::max() && "base id too high"); if (ShouldWrite) LE.write(BaseID); else LE.write(None); }; // These values should be unique within a chain, since they will be read // as keys into ContinuousRangeMaps. writeBaseIDOrNone(M->SLocEntryBaseOffset, M->LocalNumSLocEntries); writeBaseIDOrNone(M->BaseIdentifierID, M->LocalNumIdentifiers); writeBaseIDOrNone(M->BaseMacroID, M->LocalNumMacros); writeBaseIDOrNone(M->BasePreprocessedEntityID, M->NumPreprocessedEntities); writeBaseIDOrNone(M->BaseSubmoduleID, M->LocalNumSubmodules); writeBaseIDOrNone(M->BaseSelectorID, M->LocalNumSelectors); writeBaseIDOrNone(M->BaseDeclID, M->LocalNumDecls); writeBaseIDOrNone(M->BaseTypeIndex, M->LocalNumTypes); d4472 1 a4472 1 WriteSourceManagerBlock(Context.getSourceManager(), PP); d4476 1 a4476 1 WriteHeaderSearch(PP.getHeaderSearchInfo()); a4523 5 // Write the record containing potentially unused local typedefs. if (!UnusedLocalTypedefNameCandidates.empty()) Stream.EmitRecord(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES, UnusedLocalTypedefNameCandidates); a4569 3 auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) { return A.ID == B.ID; }; d4573 1 a4573 1 Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq), d4683 2 a4684 2 WriteAttributes(llvm::makeArrayRef(D->getAttrs().begin(), D->getAttrs().size()), Record); a4707 4 case UPD_DECL_MARKED_OPENMP_THREADPRIVATE: AddSourceRange(D->getAttr()->getRange(), Record); break; a5083 24 unsigned ASTWriter::getAnonymousDeclarationNumber(const NamedDecl *D) { assert(needsAnonymousDeclarationNumber(D) && "expected an anonymous declaration"); // Number the anonymous declarations within this context, if we've not // already done so. auto It = AnonymousDeclarationNumbers.find(D); if (It == AnonymousDeclarationNumbers.end()) { unsigned Index = 0; for (Decl *LexicalD : D->getLexicalDeclContext()->decls()) { auto *ND = dyn_cast(LexicalD); if (!ND || !needsAnonymousDeclarationNumber(ND)) continue; AnonymousDeclarationNumbers[ND] = Index++; } It = AnonymousDeclarationNumbers.find(D); assert(It != AnonymousDeclarationNumbers.end() && "declaration not found within its lexical context"); } return It->second; } a5170 4 case NestedNameSpecifier::Super: AddDeclRef(NNS->getAsRecordDecl(), Record); break; a5219 5 case NestedNameSpecifier::Super: AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; d5289 1 a5289 1 AddTypeRef(Arg.getParamTypeForDecl(), Record); a5520 1 case LCK_VLAType: d5624 2 a5633 1 assert(!WritingAST && "Already writing the AST!"); d5639 1 a5647 1 assert(!WritingAST && "Already writing the AST!"); d5654 1 a5658 1 assert(!WritingAST && "Already writing the AST!"); d5666 1 a5670 1 assert(!WritingAST && "Already writing the AST!"); d5678 1 a5682 1 assert(!WritingAST && "Already writing the AST!"); a5767 8 void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(const Decl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_THREADPRIVATE)); } @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @a53 1 #include "llvm/Support/Process.h" a864 1 RECORD(SIGNATURE); a1058 15 /// \brief Prepares a path for being written to an AST file by converting it /// to an absolute path and removing nested './'s. /// /// \return \c true if the path was changed. bool cleanPathForOutput(FileManager &FileMgr, SmallVectorImpl &Path) { bool Changed = false; if (!llvm::sys::path::is_absolute(StringRef(Path.data(), Path.size()))) { llvm::sys::fs::make_absolute(Path); Changed = true; } return Changed | FileMgr.removeDotPaths(Path); } d1064 2 a1065 2 /// \param BaseDir When non-NULL, the PCH file is a relocatable AST file and /// the returned filename will be adjusted by this root directory. d1070 1 a1070 1 adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir) { d1073 1 a1073 1 if (BaseDir.empty()) d1078 2 a1079 2 for (; Filename[Pos] && Pos < BaseDir.size(); ++Pos) if (Filename[Pos] != BaseDir[Pos]) d1086 4 a1089 14 // If there's not a path separator at the end of the base directory nor // immediately after it, then this isn't within the base directory. if (!llvm::sys::path::is_separator(Filename[Pos])) { if (!llvm::sys::path::is_separator(BaseDir.back())) return Filename; } else { // If the file name has a '/' at the current position, skip over the '/'. // We distinguish relative paths from absolute paths by the // absence of '/' at the beginning of relative paths. // // FIXME: This is wrong. We distinguish them by asking if the path is // absolute, which isn't the same thing. And there might be multiple '/'s // in a row. Use a better mechanism to indicate whether we have emitted an // absolute or relative path. a1090 1 } a1094 8 static ASTFileSignature getSignature() { while (1) { if (ASTFileSignature S = llvm::sys::Process::GetRandomNumber()) return S; // Rely on GetRandomNumber to eventually return non-zero... } } a1118 2 assert((!WritingModule || isysroot.empty()) && "writing module as a relocatable PCH?"); d1124 1 a1124 5 // Signature Record.clear(); Record.push_back(getSignature()); Stream.EmitRecord(SIGNATURE, Record); a1125 1 // Module name d1135 2 a1136 2 if (WritingModule && WritingModule->Directory) { // Module directory. d1138 2 a1139 2 Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory d1141 5 d1147 2 a1148 33 Record.push_back(MODULE_DIRECTORY); SmallString<128> BaseDir(WritingModule->Directory->getName()); cleanPathForOutput(Context.getSourceManager().getFileManager(), BaseDir); Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir); // Write out all other paths relative to the base directory if possible. BaseDirectory.assign(BaseDir.begin(), BaseDir.end()); } else if (!isysroot.empty()) { // Write out paths relative to the sysroot if possible. BaseDirectory = isysroot; } // Module map file if (WritingModule) { Record.clear(); auto &Map = PP.getHeaderSearchInfo().getModuleMap(); // Primary module map file. AddPath(Map.getModuleMapFileForUniquing(WritingModule)->getName(), Record); // Additional module map files. if (auto *AdditionalModMaps = Map.getAdditionalModuleMapFiles(WritingModule)) { Record.push_back(AdditionalModMaps->size()); for (const FileEntry *F : *AdditionalModMaps) AddPath(F->getName(), Record); } else { Record.push_back(0); } Stream.EmitRecord(MODULE_MAP_FILE, Record); d1166 3 a1168 2 Record.push_back((*M)->Signature); AddPath((*M)->FileName, Record); d1180 2 a1181 3 #include "clang/Basic/LangOptions.def" #define SANITIZER(NAME, ID) \ Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID)); d1315 7 d1325 1 a1325 1 EmitRecordWithPath(FileAbbrevCode, Record, MainFile->getName()); d1351 1 d1367 1 d1438 17 a1454 2 EmitRecordWithPath(IFAbbrevCode, Record, Entry.File->getName()); } a1563 3 // // FIXME: Using the mtime here will cause problems for explicit module // imports. d1644 1 a1644 1 void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) { d1668 1 a1668 1 // Massage the file path into an appropriate form. d1670 6 a1675 5 SmallString<128> FilenameTmp(Filename); if (PreparePathForOutput(FilenameTmp)) { // If we performed any translation on the file name at all, we need to // save this string, since the generator will refer to it later. Filename = strdup(FilenameTmp.c_str()); d1678 1 a1678 1 d1728 2 a1729 1 const Preprocessor &PP) { d1878 1 a1878 1 // Emit the file names. d1880 9 a1888 2 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) AddPath(LineTable.getFilename(I), Record); d2347 1 a2347 1 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/5); a2397 5 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TEXTUAL_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); a2402 5 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_TEXTUAL_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); d2474 1 a2474 1 d2476 8 a2483 13 struct { unsigned RecordKind; unsigned Abbrev; Module::HeaderKind HeaderKind; } HeaderLists[] = { {SUBMODULE_HEADER, HeaderAbbrev, Module::HK_Normal}, {SUBMODULE_TEXTUAL_HEADER, TextualHeaderAbbrev, Module::HK_Textual}, {SUBMODULE_PRIVATE_HEADER, PrivateHeaderAbbrev, Module::HK_Private}, {SUBMODULE_PRIVATE_TEXTUAL_HEADER, PrivateTextualHeaderAbbrev, Module::HK_PrivateTextual}, {SUBMODULE_EXCLUDED_HEADER, ExcludedHeaderAbbrev, Module::HK_Excluded} }; for (auto &HL : HeaderLists) { d2485 3 a2487 3 Record.push_back(HL.RecordKind); for (auto &H : Mod->Headers[HL.HeaderKind]) Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten); d2489 10 a2498 4 // Emit the top headers. { auto TopHeaders = Mod->getTopHeaders(PP->getFileManager()); d2501 2 a2502 2 for (auto *H : TopHeaders) Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, H->getName()); d2510 1 a2510 1 assert(ImportedID && "Unknown submodule!"); d2850 1 a2850 1 if (Method->getMethod()) d2854 1 a2854 1 if (Method->getMethod()) d2884 1 a2884 1 if (Method->getMethod()) d2890 1 a2890 1 if (Method->getMethod()) d2895 2 a2896 5 unsigned InstanceHasMoreThanOneDeclBit = Methods.Instance.hasMoreThanOneDecl(); unsigned FullInstanceBits = (NumInstanceMethods << 3) | (InstanceHasMoreThanOneDeclBit << 2) | InstanceBits; d2899 3 a2901 7 unsigned FactoryHasMoreThanOneDeclBit = Methods.Factory.hasMoreThanOneDecl(); unsigned FullFactoryBits = (NumFactoryMethods << 3) | (FactoryHasMoreThanOneDeclBit << 2) | FactoryBits; LE.write(FullInstanceBits); LE.write(FullFactoryBits); d2904 2 a2905 2 if (Method->getMethod()) LE.write(Writer.getDeclID(Method->getMethod())); d2908 2 a2909 2 if (Method->getMethod()) LE.write(Writer.getDeclID(Method->getMethod())); d2955 3 a2957 3 for (ObjCMethodList *M = &Data.Instance; !changed && M && M->getMethod(); M = M->getNext()) { if (!M->getMethod()->isFromASTFile()) d2960 1 a2960 1 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->getMethod(); d2962 1 a2962 1 if (!M->getMethod()->isFromASTFile()) d2967 1 a2967 1 } else if (Data.Instance.getMethod() || Data.Factory.getMethod()) { a3471 25 /// Determine the declaration that should be put into the name lookup table to /// represent the given declaration in this module. This is usually D itself, /// but if D was imported and merged into a local declaration, we want the most /// recent local declaration instead. The chosen declaration will be the most /// recent declaration in any module that imports this one. static NamedDecl *getDeclForLocalLookup(NamedDecl *D) { if (!D->isFromASTFile()) return D; if (Decl *Redecl = D->getPreviousDecl()) { // For Redeclarable decls, a prior declaration might be local. for (; Redecl; Redecl = Redecl->getPreviousDecl()) if (!Redecl->isFromASTFile()) return cast(Redecl); } else if (Decl *First = D->getCanonicalDecl()) { // For Mergeable decls, the first decl might be local. if (!First->isFromASTFile()) return cast(First); } // All declarations are imported. Our most recent declaration will also be // the most recent one in anyone who imports us. return D; } d3589 1 a3589 1 LE.write(Writer.GetDeclRef(getDeclForLocalLookup(*I))); d3629 1 a3629 1 if (UpdatedDeclContexts.insert(DC).second && WritingAST) { d3635 1 a3635 1 GetDeclRef(getDeclForLocalLookup(Decl)); a3831 2 // FIXME: Do we need to do this for the first declaration from each // redeclaration chain that was merged into this one? a4016 31 bool ASTWriter::PreparePathForOutput(SmallVectorImpl &Path) { assert(Context && "should have context when outputting path"); bool Changed = cleanPathForOutput(Context->getSourceManager().getFileManager(), Path); // Remove a prefix to make the path relative, if relevant. const char *PathBegin = Path.data(); const char *PathPtr = adjustFilenameForRelocatableAST(PathBegin, BaseDirectory); if (PathPtr != PathBegin) { Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin)); Changed = true; } return Changed; } void ASTWriter::AddPath(StringRef Path, RecordDataImpl &Record) { SmallString<128> FilePath(Path); PreparePathForOutput(FilePath); AddString(FilePath, Record); } void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataImpl &Record, StringRef Path) { SmallString<128> FilePath(Path); PreparePathForOutput(FilePath); Stream.EmitRecordWithBlob(Abbrev, Record, FilePath); } a4100 1 this->BaseDirectory.clear(); a4249 5 // Build a record containing all of the UnusedLocalTypedefNameCandidates. RecordData UnusedLocalTypedefNameCandidates; for (const TypedefNameDecl *TD : SemaRef.UnusedLocalTypedefNameCandidates) AddDeclRef(TD, UnusedLocalTypedefNameCandidates); d4416 3 a4418 1 for (ModuleFile *M : Chain->ModuleMgr) { d4421 1 a4421 1 StringRef FileName = M->FileName; d4424 8 a4431 24 // Note: if a base ID was uint max, it would not be possible to load // another module after it or have more than one entity inside it. uint32_t None = std::numeric_limits::max(); auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) { assert(BaseID < std::numeric_limits::max() && "base id too high"); if (ShouldWrite) LE.write(BaseID); else LE.write(None); }; // These values should be unique within a chain, since they will be read // as keys into ContinuousRangeMaps. writeBaseIDOrNone(M->SLocEntryBaseOffset, M->LocalNumSLocEntries); writeBaseIDOrNone(M->BaseIdentifierID, M->LocalNumIdentifiers); writeBaseIDOrNone(M->BaseMacroID, M->LocalNumMacros); writeBaseIDOrNone(M->BasePreprocessedEntityID, M->NumPreprocessedEntities); writeBaseIDOrNone(M->BaseSubmoduleID, M->LocalNumSubmodules); writeBaseIDOrNone(M->BaseSelectorID, M->LocalNumSelectors); writeBaseIDOrNone(M->BaseDeclID, M->LocalNumDecls); writeBaseIDOrNone(M->BaseTypeIndex, M->LocalNumTypes); d4472 1 a4472 1 WriteSourceManagerBlock(Context.getSourceManager(), PP); d4476 1 a4476 1 WriteHeaderSearch(PP.getHeaderSearchInfo()); a4523 5 // Write the record containing potentially unused local typedefs. if (!UnusedLocalTypedefNameCandidates.empty()) Stream.EmitRecord(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES, UnusedLocalTypedefNameCandidates); a4569 3 auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) { return A.ID == B.ID; }; d4573 1 a4573 1 Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq), d4683 2 a4684 2 WriteAttributes(llvm::makeArrayRef(D->getAttrs().begin(), D->getAttrs().size()), Record); a4707 4 case UPD_DECL_MARKED_OPENMP_THREADPRIVATE: AddSourceRange(D->getAttr()->getRange(), Record); break; a5083 24 unsigned ASTWriter::getAnonymousDeclarationNumber(const NamedDecl *D) { assert(needsAnonymousDeclarationNumber(D) && "expected an anonymous declaration"); // Number the anonymous declarations within this context, if we've not // already done so. auto It = AnonymousDeclarationNumbers.find(D); if (It == AnonymousDeclarationNumbers.end()) { unsigned Index = 0; for (Decl *LexicalD : D->getLexicalDeclContext()->decls()) { auto *ND = dyn_cast(LexicalD); if (!ND || !needsAnonymousDeclarationNumber(ND)) continue; AnonymousDeclarationNumbers[ND] = Index++; } It = AnonymousDeclarationNumbers.find(D); assert(It != AnonymousDeclarationNumbers.end() && "declaration not found within its lexical context"); } return It->second; } a5170 4 case NestedNameSpecifier::Super: AddDeclRef(NNS->getAsRecordDecl(), Record); break; a5219 5 case NestedNameSpecifier::Super: AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; d5289 1 a5289 1 AddTypeRef(Arg.getParamTypeForDecl(), Record); a5520 1 case LCK_VLAType: d5624 2 a5633 1 assert(!WritingAST && "Already writing the AST!"); d5639 1 a5647 1 assert(!WritingAST && "Already writing the AST!"); d5654 1 a5658 1 assert(!WritingAST && "Already writing the AST!"); d5666 1 a5670 1 assert(!WritingAST && "Already writing the AST!"); d5678 1 a5682 1 assert(!WritingAST && "Already writing the AST!"); a5767 8 void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(const Decl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_THREADPRIVATE)); } @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @d1 1 a1 1 //===--- ASTWriter.cpp - AST File Writer ------------------------*- C++ -*-===// a14 1 #include "clang/Serialization/ModuleFileExtension.h" a15 2 #include "ASTReaderInternals.h" #include "MultiOnDiskHashTable.h" a43 1 #include "clang/Serialization/SerializationDiagnostic.h" a58 1 d63 1 a63 1 static StringRef bytes(const std::vector &v) { d70 1 a70 1 static StringRef bytes(const SmallVectorImpl &v) { d101 1 a101 1 } // end anonymous namespace d280 1 a280 1 Record.push_back((unsigned)T->getKeyword()); d332 3 a334 2 for (const auto &ArgI : *T) Writer.AddTemplateArgument(ArgI, Record); d384 3 a386 2 for (const auto &I : *T) Writer.AddTemplateArgument(I, Record); a423 3 Record.push_back(T->getTypeArgsAsWritten().size()); for (auto TypeArg : T->getTypeArgsAsWritten()) Writer.AddTypeRef(TypeArg, Record); a426 1 Record.push_back(T->isKindOfTypeAsWritten()); a441 6 void ASTTypeWriter::VisitPipeType(const PipeType *T) { Writer.AddTypeRef(T->getElementType(), Record); Code = TYPE_PIPE; } d461 1 a461 1 } // end anonymous namespace d651 2 a652 6 Writer.AddSourceLocation(TL.getTypeArgsLAngleLoc(), Record); Writer.AddSourceLocation(TL.getTypeArgsRAngleLoc(), Record); for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i) Writer.AddTypeSourceInfo(TL.getTypeArgTInfo(i), Record); Writer.AddSourceLocation(TL.getProtocolLAngleLoc(), Record); Writer.AddSourceLocation(TL.getProtocolRAngleLoc(), Record); a663 3 void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) { Writer.AddSourceLocation(TL.getKWLoc(), Record); } a776 1 RECORD(EXPR_DESIGNATED_INIT_UPDATE); a777 1 RECORD(EXPR_NO_INIT); a867 1 RECORD(MODULE_DIRECTORY); d870 2 a875 4 BLOCK(OPTIONS_BLOCK); RECORD(LANGUAGE_OPTIONS); RECORD(TARGET_OPTIONS); d894 2 a901 1 RECORD(UNUSED_FILESCOPED_DECLS); a902 1 RECORD(VTABLE_USES); d905 1 d921 1 d927 2 d931 1 a931 2 RECORD(INTERESTING_IDENTIFIERS); RECORD(UNDEFINED_BUT_USED); a933 3 RECORD(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES); RECORD(CXX_CTOR_INITIALIZERS_OFFSETS); RECORD(DELETE_EXPRS_TO_ANALYZE); d944 1 a944 1 RECORD(PP_MACRO_DIRECTIVE_HISTORY); a945 2 RECORD(PP_MACRO_OBJECT_LIKE); RECORD(PP_MODULE_MACRO); d947 1 a947 24 // Submodule Block. BLOCK(SUBMODULE_BLOCK); RECORD(SUBMODULE_METADATA); RECORD(SUBMODULE_DEFINITION); RECORD(SUBMODULE_UMBRELLA_HEADER); RECORD(SUBMODULE_HEADER); RECORD(SUBMODULE_TOPHEADER); RECORD(SUBMODULE_UMBRELLA_DIR); RECORD(SUBMODULE_IMPORTS); RECORD(SUBMODULE_EXPORTS); RECORD(SUBMODULE_REQUIRES); RECORD(SUBMODULE_EXCLUDED_HEADER); RECORD(SUBMODULE_LINK_LIBRARY); RECORD(SUBMODULE_CONFIG_MACRO); RECORD(SUBMODULE_CONFLICT); RECORD(SUBMODULE_PRIVATE_HEADER); RECORD(SUBMODULE_TEXTUAL_HEADER); RECORD(SUBMODULE_PRIVATE_TEXTUAL_HEADER); // Comments Block. BLOCK(COMMENTS_BLOCK); RECORD(COMMENTS_RAW_COMMENT); a990 1 RECORD(LOCAL_REDECLARATIONS); d1055 1 a1055 5 // Decls and Types block. BLOCK(EXTENSION_BLOCK); RECORD(EXTENSION_METADATA); d1065 9 a1073 4 static bool cleanPathForOutput(FileManager &FileMgr, SmallVectorImpl &Path) { bool Changed = FileMgr.makeAbsolutePath(Path); return Changed | llvm::sys::path::remove_dots(Path); d1132 3 a1134 6 uint64_t ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, StringRef isysroot, const std::string &OutputFile) { ASTFileSignature Signature = 0; d1140 1 a1140 1 auto *MetadataAbbrev = new BitCodeAbbrev(); a1146 1 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Timestamps d1150 5 d1157 10 a1166 8 { RecordData::value_type Record[] = {METADATA, VERSION_MAJOR, VERSION_MINOR, CLANG_VERSION_MAJOR, CLANG_VERSION_MINOR, !isysroot.empty(), IncludeTimestamps, ASTHasCompilerErrors}; Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, getClangFullRepositoryVersion()); } a1167 10 // For implicit modules we output a signature that we can use to ensure // duplicate module builds don't collide in the cache as their output order // is non-deterministic. // FIXME: Remove this when output is deterministic. if (Context.getLangOpts().ImplicitModules) { Signature = getSignature(); RecordData::value_type Record[] = {Signature}; Stream.EmitRecord(SIGNATURE, Record); } d1169 1 a1169 1 auto *Abbrev = new BitCodeAbbrev(); d1173 2 a1174 1 RecordData::value_type Record[] = {MODULE_NAME}; d1179 8 d1189 1 a1189 17 // If the home of the module is the current working directory, then we // want to pick up the cwd of the build process loading the module, not // our cwd, when we load this module. if (!PP.getHeaderSearchInfo() .getHeaderSearchOpts() .ModuleMapFileHomeIsCwd || WritingModule->Directory->getName() != StringRef(".")) { // Module directory. auto *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); RecordData::value_type Record[] = {MODULE_DIRECTORY}; Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir); } d1225 2 a1226 1 for (auto *M : Mgr) { d1228 1 a1228 1 if (!M->isDirectlyImported()) d1231 6 a1236 6 Record.push_back((unsigned)M->Kind); // FIXME: Stable encoding AddSourceLocation(M->ImportLoc, Record); Record.push_back(M->File->getSize()); Record.push_back(getTimestampForOutput(M->File)); Record.push_back(M->Signature); AddPath(M->FileName, Record); a1240 3 // Write the options block. Stream.EnterSubblock(OPTIONS_BLOCK_ID, 4); a1252 4 Record.push_back(LangOpts.ModuleFeatures.size()); for (StringRef Feature : LangOpts.ModuleFeatures) AddString(Feature, Record); d1255 3 a1257 2 AddString(LangOpts.CurrentModule, Record); d1261 5 a1265 2 for (const auto &I : LangOpts.CommentOpts.BlockCommandNames) { AddString(I, Record); a1268 7 // OpenMP offloading options. Record.push_back(LangOpts.OMPTargetTriples.size()); for (auto &T : LangOpts.OMPTargetTriples) AddString(T.getTriple(), Record); AddString(LangOpts.OMPHostIRFile, Record); d1308 2 a1309 2 const FileSystemOptions &FSOpts = Context.getSourceManager().getFileManager().getFileSystemOpts(); a1343 2 // Write out the specific module cache path that contains the module files. AddString(PP.getHeaderSearchInfo().getModuleCachePath(), Record); a1374 3 // Leave the options block. Stream.ExitBlock(); d1378 1 a1378 1 auto *FileAbbrev = new BitCodeAbbrev(); d1396 1 a1396 1 auto *Abbrev = new BitCodeAbbrev(); d1403 1 a1403 1 SM.getFileManager().makeAbsolutePath(OutputPath); d1406 2 a1407 1 RecordData::value_type Record[] = {ORIGINAL_PCH_DIR}; a1414 1 return Signature; a1421 1 bool IsTransient; d1424 1 a1424 1 } // end anonymous namespace d1431 2 a1432 1 d1434 1 a1434 1 auto *IFAbbrev = new BitCodeAbbrev(); a1439 1 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Transient a1460 1 Entry.IsTransient = Cache->IsTransient; d1470 5 a1474 2 std::vector InputFileOffsets; for (const auto &Entry : SortedFiles) { d1487 4 d1492 5 a1496 8 // And whether this file was overridden. RecordData::value_type Record[] = { INPUT_FILE, InputFileOffsets.size(), (uint64_t)Entry.File->getSize(), (uint64_t)getTimestampForOutput(Entry.File), Entry.BufferOverridden, Entry.IsTransient}; d1504 1 a1504 1 auto *OffsetsAbbrev = new BitCodeAbbrev(); d1513 5 a1517 3 RecordData::value_type Record[] = {INPUT_FILE_OFFSETS, InputFileOffsets.size(), UserFilesNum}; Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, bytes(InputFileOffsets)); d1528 1 a1528 2 auto *Abbrev = new BitCodeAbbrev(); d1546 1 a1546 2 auto *Abbrev = new BitCodeAbbrev(); d1560 1 a1560 2 auto *Abbrev = new BitCodeAbbrev(); d1570 1 a1570 2 auto *Abbrev = new BitCodeAbbrev(); d1605 1 a1605 1 hash_value_type ComputeHash(key_type_ref key) { d1609 3 d1613 1 a1613 1 Writer.getTimestampForOutput(key.FE)); d1619 1 a1619 1 endian::Writer LE(Out); d1621 1 a1621 1 LE.write(KeyLen); d1623 3 a1625 4 for (auto ModInfo : HS.getModuleMap().findAllModulesForHeader(key.FE)) if (Writer.getLocalOrImportedSubmoduleID(ModInfo.getModule())) DataLen += 4; LE.write(DataLen); d1634 1 a1634 1 LE.write(Writer.getTimestampForOutput(key.FE)); d1645 5 a1649 3 unsigned char Flags = (Data.isImport << 4) | (Data.isPragmaOnce << 3) | (Data.DirInfo << 1) d1676 3 a1678 9 // FIXME: If the header is excluded, we should write out some // record of that fact. for (auto ModInfo : HS.getModuleMap().findAllModulesForHeader(key.FE)) { if (uint32_t ModID = Writer.getLocalOrImportedSubmoduleID(ModInfo.getModule())) { uint32_t Value = (ModID << 2) | (unsigned)ModInfo.getRole(); assert((Value >> 2) == ModID && "overflow in header module info"); LE.write(Value); } d1708 6 a1713 9 // Get the file info. This will load info from the external source if // necessary. Skip emitting this file if we have no information on it // as a header file (in which case HFI will be null) or if it hasn't // changed since it was loaded. Also skip it if it's for a modular header // from a different module; in that case, we rely on the module(s) // containing the header to provide this information. const HeaderFileInfo *HFI = HS.getExistingFileInfo(File, /*WantExternal*/!Chain); if (!HFI || (HFI->isModuleHeader && !HFI->isCompilingModuleHeader)) d1727 1 a1727 1 Generator.insert(key, *HFI, GeneratorTrait); d1744 1 a1744 2 auto *Abbrev = new BitCodeAbbrev(); d1753 5 a1757 2 RecordData::value_type Record[] = {HEADER_SEARCH_TABLE, BucketOffset, NumHeaderSearchEntries, TableData.size()}; d1759 1 a1759 1 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData); d1845 3 a1847 2 if (Content->BufferOverridden || Content->IsTransient) { RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB}; d1866 2 a1867 1 RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB}; d1901 1 a1901 2 auto *Abbrev = new BitCodeAbbrev(); d1907 7 a1913 7 { RecordData::value_type Record[] = { SOURCE_LOCATION_OFFSETS, SLocEntryOffsets.size(), SourceMgr.getNextLocalOffset() - 1 /* skip dummy */}; Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, bytes(SLocEntryOffsets)); } d1924 4 a1927 13 // Emit the needed file names. llvm::DenseMap FilenameMap; for (const auto &L : LineTable) { if (L.first.ID < 0) continue; for (auto &LE : L.second) { if (FilenameMap.insert(std::make_pair(LE.FilenameID, FilenameMap.size())).second) AddPath(LineTable.getFilename(LE.FilenameID), Record); } } Record.push_back(0); d1930 2 a1931 1 for (const auto &L : LineTable) { d1933 1 a1933 1 if (L.first.ID < 0) d1937 1 a1937 1 Record.push_back(L.first.ID); d1940 9 a1948 7 Record.push_back(L.second.size()); for (const auto &LE : L.second) { Record.push_back(LE.FileOffset); Record.push_back(LE.LineNo); Record.push_back(FilenameMap[LE.FilenameID]); Record.push_back((unsigned)LE.FileKind); Record.push_back(LE.IncludeOffset); a1950 1 d1959 46 d2012 4 a2034 1 RecordData ModuleMacroRecord; d2038 1 a2038 1 RecordData::value_type Record[] = {PP.getCounterValue()}; d2040 1 d2047 1 a2047 1 // FIXME: Include a location for the use, and say which one was used. d2049 2 a2050 1 PP.Diag(SourceLocation(), diag::warn_module_uses_date_time) << IsModule; d2055 10 a2064 8 // Construct the list of identifiers with macro directives that need to be // serialized. SmallVector MacroIdentifiers; for (auto &Id : PP.getIdentifierTable()) if (Id.second->hadMacroDefinition() && (!Id.second->isFromAST() || Id.second->hasChangedSinceDeserialization())) MacroIdentifiers.push_back(Id.second); d2067 4 a2070 2 std::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), llvm::less_ptr()); d2074 11 a2084 3 for (const IdentifierInfo *Name : MacroIdentifiers) { MacroDirective *MD = PP.getLocalMacroDirectiveHistory(Name); auto StartOffset = Stream.GetCurrentBitNo(); a2087 2 // Once we hit an ignored macro, we're done: the rest of the chain // will all be ignored macros. d2089 1 a2089 1 break; d2094 8 a2101 2 Record.push_back(getMacroRef(DefMD->getInfo(), Name)); } else if (auto *VisMD = dyn_cast(MD)) { a2103 1 } d2105 5 a2109 25 // Write out any exported module macros. bool EmittedModuleMacros = false; if (IsModule) { auto Leafs = PP.getLeafModuleMacros(Name); SmallVector Worklist(Leafs.begin(), Leafs.end()); llvm::DenseMap Visits; while (!Worklist.empty()) { auto *Macro = Worklist.pop_back_val(); // Emit a record indicating this submodule exports this macro. ModuleMacroRecord.push_back( getSubmoduleID(Macro->getOwningModule())); ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name)); for (auto *M : Macro->overrides()) ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule())); Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); ModuleMacroRecord.clear(); // Enqueue overridden macros once we've visited all their ancestors. for (auto *M : Macro->overrides()) if (++Visits[M] == M->getNumOverridingMacros()) Worklist.push_back(M); EmittedModuleMacros = true; d2112 1 a2112 2 if (Record.empty() && !EmittedModuleMacros) a2114 1 IdentMacroDirectivesOffsetMap[Name] = StartOffset; d2117 7 d2171 3 a2173 2 for (const IdentifierInfo *Arg : MI->args()) AddIdentifierRef(Arg, Record); d2199 24 d2225 1 a2225 2 auto *Abbrev = new BitCodeAbbrev(); d2232 6 a2237 5 { RecordData::value_type Record[] = {MACRO_OFFSET, MacroOffsets.size(), FirstMacroID - NUM_PREDEF_MACRO_IDS}; Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, bytes(MacroOffsets)); } d2256 1 a2256 1 auto *Abbrev = new BitCodeAbbrev(); d2277 2 a2278 2 PreprocessedEntityOffsets.push_back( PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo())); d2280 1 a2280 1 if (auto *MD = dyn_cast(*E)) { d2283 1 a2283 1 d2289 1 a2289 1 if (auto *ME = dyn_cast(*E)) { d2299 1 a2299 1 if (auto *ID = dyn_cast(*E)) { d2325 1 a2325 2 auto *Abbrev = new BitCodeAbbrev(); d2331 3 a2333 3 RecordData::value_type Record[] = {PPD_ENTITIES_OFFSETS, FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS}; d2335 1 a2335 1 bytes(PreprocessedEntityOffsets)); d2339 1 a2339 4 unsigned ASTWriter::getLocalOrImportedSubmoduleID(Module *Mod) { if (!Mod) return 0; d2343 3 d2347 2 a2348 1 if (Mod->getTopLevelModule() != WritingModule) d2351 4 a2354 2 return SubmoduleIDs[Mod] = NextSubmoduleID++; } d2356 1 a2356 8 unsigned ASTWriter::getSubmoduleID(Module *Mod) { // FIXME: This can easily happen, if we have a reference to a submodule that // did not result in us loading a module file for that submodule. For // instance, a cross-top-level-module 'conflict' declaration will hit this. unsigned ID = getLocalOrImportedSubmoduleID(Mod); assert((ID || !Mod) && "asked for module ID for non-local, non-imported module"); return ID; d2363 2 a2364 1 for (auto Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); d2372 13 d2390 1 a2390 2 auto *Abbrev = new BitCodeAbbrev(); d2469 3 a2471 3 RecordData::value_type Record[] = {getNumberOfModules(WritingModule), FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS}; d2481 5 a2485 2 uint64_t ParentID = 0; d2488 3 a2490 1 ParentID = SubmoduleIDs[Mod->Parent]; d2492 10 a2501 11 // Emit the definition of the block. { RecordData::value_type Record[] = { SUBMODULE_DEFINITION, ID, ParentID, Mod->IsFramework, Mod->IsExplicit, Mod->IsSystem, Mod->IsExternC, Mod->InferSubmodules, Mod->InferExplicitSubmodules, Mod->InferExportWildcard, Mod->ConfigMacrosExhaustive}; Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); } d2503 6 a2508 3 for (const auto &R : Mod->Requirements) { RecordData::value_type Record[] = {SUBMODULE_REQUIRES, R.second}; Stream.EmitRecordWithBlob(RequiresAbbrev, Record, R.first); d2512 10 a2521 8 if (auto UmbrellaHeader = Mod->getUmbrellaHeader()) { RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_HEADER}; Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, UmbrellaHeader.NameAsWritten); } else if (auto UmbrellaDir = Mod->getUmbrellaDir()) { RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_DIR}; Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, UmbrellaDir.NameAsWritten); d2538 2 a2539 1 RecordData::value_type Record[] = {HL.RecordKind}; d2547 2 a2548 1 RecordData::value_type Record[] = {SUBMODULE_TOPHEADER}; d2555 6 a2560 3 RecordData Record; for (auto *I : Mod->Imports) Record.push_back(getSubmoduleID(I)); d2566 11 a2576 6 RecordData Record; for (const auto &E : Mod->Exports) { // FIXME: This may fail; we don't require that all exported modules // are local or imported. Record.push_back(getSubmoduleID(E.getPointer())); Record.push_back(E.getInt()); d2586 6 a2591 4 for (const auto &LL : Mod->LinkLibraries) { RecordData::value_type Record[] = {SUBMODULE_LINK_LIBRARY, LL.IsFramework}; Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, LL.Library); d2595 8 a2602 6 for (const auto &C : Mod->Conflicts) { // FIXME: This may fail; we don't require that all conflicting modules // are local or imported. RecordData::value_type Record[] = {SUBMODULE_CONFLICT, getSubmoduleID(C.Other)}; Stream.EmitRecordWithBlob(ConflictAbbrev, Record, C.Message); d2606 5 a2610 3 for (const auto &CM : Mod->ConfigMacros) { RecordData::value_type Record[] = {SUBMODULE_CONFIG_MACRO}; Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, CM); d2614 4 a2617 2 for (auto *M : Mod->submodules()) Q.push(M); d2621 3 a2623 5 assert((NextSubmoduleID - FirstSubmoduleID == getNumberOfModules(WritingModule)) && "Wrong # of submodules; found a reference to a non-local, " "non-imported submodule?"); d2671 5 a2675 4 for (const auto &I : *(point.State)) { if (I.second.isPragma()) { Record.push_back(I.first); Record.push_back((unsigned)I.second.getSeverity()); a2686 20 void ASTWriter::WriteCXXCtorInitializersOffsets() { if (CXXCtorInitializersOffsets.empty()) return; // Create a blob abbreviation for the C++ ctor initializer offsets. using namespace llvm; auto *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(CXX_CTOR_INITIALIZERS_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned CtorInitializersOffsetAbbrev = Stream.EmitAbbrev(Abbrev); // Write the base specifier offsets table. RecordData::value_type Record[] = {CXX_CTOR_INITIALIZERS_OFFSETS, CXXCtorInitializersOffsets.size()}; Stream.EmitRecordWithBlob(CtorInitializersOffsetAbbrev, Record, bytes(CXXCtorInitializersOffsets)); } d2691 2 d2696 1 a2696 1 auto *Abbrev = new BitCodeAbbrev(); d2703 3 a2705 2 RecordData::value_type Record[] = {CXX_BASE_SPECIFIER_OFFSETS, CXXBaseSpecifiersOffsets.size()}; d2707 1 a2707 1 bytes(CXXBaseSpecifiersOffsets)); d2776 5 a2780 5 SmallVector KindDeclPairs; for (const auto *D : DC->decls()) { KindDeclPairs.push_back(D->getKind()); KindDeclPairs.push_back(GetDeclRef(D)); } d2783 1 a2783 3 RecordData::value_type Record[] = {DECL_CONTEXT_LEXICAL}; Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, bytes(KindDeclPairs)); d2789 1 d2792 1 a2792 1 auto *Abbrev = new BitCodeAbbrev(); d2798 5 a2802 5 { RecordData::value_type Record[] = {TYPE_OFFSET, TypeOffsets.size(), FirstTypeID - NUM_PREDEF_TYPE_IDS}; Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, bytes(TypeOffsets)); } d2811 5 a2815 5 { RecordData::value_type Record[] = {DECL_OFFSET, DeclOffsets.size(), FirstDeclID - NUM_PREDEF_DECL_IDS}; Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, bytes(DeclOffsets)); } d2820 1 a2820 5 SmallVector, 64> SortedFileDeclIDs( FileDeclIDs.begin(), FileDeclIDs.end()); std::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), llvm::less_first()); d2823 8 a2830 6 SmallVector FileGroupedDeclIDs; for (auto &FileDeclEntry : SortedFileDeclIDs) { DeclIDInFileInfo &Info = *FileDeclEntry.second; Info.FirstDeclIndex = FileGroupedDeclIDs.size(); for (auto &LocDeclEntry : Info.DeclIDs) FileGroupedDeclIDs.push_back(LocDeclEntry.second); d2833 1 a2833 1 auto *Abbrev = new BitCodeAbbrev(); d2838 3 a2840 3 RecordData::value_type Record[] = {FILE_SORTED_DECLS, FileGroupedDeclIDs.size()}; Stream.EmitRecordWithBlob(AbbrevCode, Record, bytes(FileGroupedDeclIDs)); d2847 3 a2849 1 for (const auto *I : RawComments) { d2851 4 a2854 4 AddSourceRange(I->getSourceRange(), Record); Record.push_back(I->getKind()); Record.push_back(I->isTrailingComment()); Record.push_back(I->isAlmostTrailingComment()); d2991 4 a2994 3 for (auto &SelectorAndID : SelectorIDs) { Selector S = SelectorAndID.first; SelectorID ID = SelectorAndID.second; d2997 1 a2997 1 ID, d3007 1 a3007 1 if (Chain && ID < FirstSelectorID) { d3042 1 a3042 1 auto *Abbrev = new BitCodeAbbrev(); d3050 5 a3054 5 { RecordData::value_type Record[] = {METHOD_POOL, BucketOffset, NumTableEntries}; Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool); } d3065 6 a3070 7 { RecordData::value_type Record[] = { SELECTOR_OFFSETS, SelectorOffsets.size(), FirstSelectorID - NUM_PREDEF_SELECTOR_IDS}; Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, bytes(SelectorOffsets)); } d3085 5 a3089 3 for (auto &SelectorAndLocation : SemaRef.ReferencedSelectors) { Selector Sel = SelectorAndLocation.first; SourceLocation Loc = SelectorAndLocation.second; d3100 17 a3116 9 /// Determine the declaration that should be put into the name lookup table to /// represent the given declaration in this module. This is usually D itself, /// but if D was imported and merged into a local declaration, we want the most /// recent local declaration instead. The chosen declaration will be the most /// recent declaration in any module that imports this one. static NamedDecl *getDeclForLocalLookup(const LangOptions &LangOpts, NamedDecl *D) { if (!LangOpts.Modules || !D->isFromASTFile()) return D; d3118 60 a3177 8 if (Decl *Redecl = D->getPreviousDecl()) { // For Redeclarable decls, a prior declaration might be local. for (; Redecl; Redecl = Redecl->getPreviousDecl()) { if (!Redecl->isFromASTFile()) return cast(Redecl); // If we find a decl from a (chained-)PCH stop since we won't find a // local one. if (D->getOwningModuleID() == 0) d3179 22 d3202 2 a3203 4 } else if (Decl *First = D->getCanonicalDecl()) { // For Mergeable decls, the first decl might be local. if (!First->isFromASTFile()) return cast(First); d3206 51 a3256 4 // All declarations are imported. Our most recent declaration will also be // the most recent one in anyone who imports us. return D; } d3258 5 a3262 20 namespace { class ASTIdentifierTableTrait { ASTWriter &Writer; Preprocessor &PP; IdentifierResolver &IdResolver; bool IsModule; bool NeedDecls; ASTWriter::RecordData *InterestingIdentifierOffsets; /// \brief Determines whether this is an "interesting" identifier that needs a /// full IdentifierInfo structure written into the hash table. Notably, this /// doesn't check whether the name has macros defined; use PublicMacroIterator /// to check that. bool isInterestingIdentifier(const IdentifierInfo *II, uint64_t MacroOffset) { if (MacroOffset || II->isPoisoned() || (IsModule ? II->hasRevertedBuiltin() : II->getObjCOrBuiltinID()) || II->hasRevertedTokenIDToIdentifier() || (NeedDecls && II->getFETokenInfo())) return true; d3264 2 a3265 1 return false; d3278 3 a3280 6 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, IdentifierResolver &IdResolver, bool IsModule, ASTWriter::RecordData *InterestingIdentifierOffsets) : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule), NeedDecls(!IsModule || !Writer.getLangOpts().CPlusPlus), InterestingIdentifierOffsets(InterestingIdentifierOffsets) {} a3285 8 bool isInterestingIdentifier(const IdentifierInfo *II) { auto MacroOffset = Writer.getMacroDirectivesOffset(II); return isInterestingIdentifier(II, MacroOffset); } bool isInterestingNonMacroIdentifier(const IdentifierInfo *II) { return isInterestingIdentifier(II, 0); } d3290 2 a3291 2 auto MacroOffset = Writer.getMacroDirectivesOffset(II); if (isInterestingIdentifier(II, MacroOffset)) { d3294 1 a3294 1 if (MacroOffset) d3296 13 d3310 4 a3313 6 if (NeedDecls) { for (IdentifierResolver::iterator D = IdResolver.begin(II), DEnd = IdResolver.end(); D != DEnd; ++D) DataLen += 4; } a3317 1 assert((uint16_t)DataLen == DataLen && (uint16_t)KeyLen == KeyLen); d3331 2 d3334 11 a3344 6 // Emit the offset of the key/data length information to the interesting // identifiers table if necessary. if (InterestingIdentifierOffsets && isInterestingIdentifier(II)) InterestingIdentifierOffsets->push_back(Out.tell() - 4); Out.write(II->getNameStart(), KeyLen); d3351 2 a3352 3 auto MacroOffset = Writer.getMacroDirectivesOffset(II); if (!isInterestingIdentifier(II, MacroOffset)) { d3362 1 a3362 1 bool HadMacroDefinition = MacroOffset != 0; d3364 1 a3366 1 Bits = (Bits << 1) | unsigned(II->hasRevertedBuiltin()); d3371 28 a3398 2 if (HadMacroDefinition) LE.write(MacroOffset); d3400 30 a3429 14 if (NeedDecls) { // Emit the declaration IDs in reverse order, because the // IdentifierResolver provides the declarations as they would be // visible (e.g., the function "stat" would come before the struct // "stat"), but the ASTReader adds declarations to the end of the list // (so we need to see the struct "stat" before the function "stat"). // Only emit declarations that aren't from a chained PCH, though. SmallVector Decls(IdResolver.begin(II), IdResolver.end()); for (SmallVectorImpl::reverse_iterator D = Decls.rbegin(), DEnd = Decls.rend(); D != DEnd; ++D) LE.write( Writer.getDeclID(getDeclForLocalLookup(PP.getLangOpts(), *D))); d3431 2 a3446 2 RecordData InterestingIdents; d3451 1 a3451 3 ASTIdentifierTableTrait Trait( *this, PP, IdResolver, IsModule, (getLangOpts().CPlusPlus && IsModule) ? &InterestingIdents : nullptr); d3458 4 a3461 9 SmallVector IIs; for (const auto &ID : PP.getIdentifierTable()) IIs.push_back(ID.second); // Sort the identifiers lexicographically before getting them references so // that their order is stable. std::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); for (const IdentifierInfo *II : IIs) if (Trait.isInterestingNonMacroIdentifier(II)) getIdentifierRef(II); d3466 8 a3473 6 for (auto IdentIDPair : IdentifierIDs) { auto *II = const_cast(IdentIDPair.first); IdentID ID = IdentIDPair.second; assert(II && "NULL identifier in identifier table"); if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) Generator.insert(II, ID, Trait); d3481 1 d3489 1 a3489 1 auto *Abbrev = new BitCodeAbbrev(); d3496 4 a3499 2 RecordData::value_type Record[] = {IDENTIFIER_TABLE, BucketOffset}; Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable); d3503 1 a3503 1 auto *Abbrev = new BitCodeAbbrev(); d3514 5 a3518 4 RecordData::value_type Record[] = {IDENTIFIER_OFFSET, IdentifierOffsets.size(), FirstIdentID - NUM_PREDEF_IDENT_IDS}; d3520 1 a3520 6 bytes(IdentifierOffsets)); // In C++, write the list of interesting identifiers (those that are // defined as macros, poisoned, or similar unusual things). if (!InterestingIdents.empty()) Stream.EmitRecord(INTERESTING_IDENTIFIERS, InterestingIdents); d3527 25 a3555 1 llvm::SmallVector DeclIDs; d3558 1 a3558 1 typedef DeclarationNameKey key_type; d3561 1 a3561 2 /// A start and end index into DeclIDs, representing a sequence of decls. typedef std::pair data_type; d3569 24 a3592 6 template data_type getData(const Coll &Decls) { unsigned Start = DeclIDs.size(); for (NamedDecl *D : Decls) { DeclIDs.push_back( Writer.GetDeclRef(getDeclForLocalLookup(Writer.getLangOpts(), D))); a3593 2 return std::make_pair(Start, DeclIDs.size()); } d3595 1 a3595 5 data_type ImportData(const reader::ASTDeclContextNameLookupTrait::data_type &FromReader) { unsigned Start = DeclIDs.size(); for (auto ID : FromReader) DeclIDs.push_back(ID); return std::make_pair(Start, DeclIDs.size()); d3598 3 a3600 20 static bool EqualKey(key_type_ref a, key_type_ref b) { return a == b; } hash_value_type ComputeHash(DeclarationNameKey Name) { return Name.getHash(); } void EmitFileRef(raw_ostream &Out, ModuleFile *F) const { assert(Writer.hasChain() && "have reference to loaded module file but no chain?"); using namespace llvm::support; endian::Writer(Out) .write(Writer.getChain()->getModuleFileID(F)); } std::pair EmitKeyDataLength(raw_ostream &Out, DeclarationNameKey Name, data_type_ref Lookup) { d3604 1 a3604 1 switch (Name.getKind()) { d3623 2 a3624 4 // 4 bytes for each DeclID. unsigned DataLen = 4 * (Lookup.second - Lookup.first); assert(uint16_t(DataLen) == DataLen && "too many decls for serialized lookup result"); d3630 1 a3630 1 void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) { d3633 2 a3634 2 LE.write(Name.getKind()); switch (Name.getKind()) { d3636 1 a3636 2 case DeclarationName::CXXLiteralOperatorName: LE.write(Writer.getIdentifierRef(Name.getIdentifier())); d3641 1 a3641 1 LE.write(Writer.getSelectorRef(Name.getSelector())); d3644 1 a3644 1 assert(Name.getOperatorKind() < NUM_OVERLOADED_OPERATORS && d3646 4 a3649 1 LE.write(Name.getOperatorKind()); d3661 2 a3662 2 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup, unsigned DataLen) { d3666 5 a3670 2 for (unsigned I = Lookup.first, N = Lookup.second; I != N; ++I) LE.write(DeclIDs[I]); d3676 4 a3679 21 bool ASTWriter::isLookupResultExternal(StoredDeclsList &Result, DeclContext *DC) { return Result.hasExternalDecls() && DC->NeedToReconcileExternalVisibleStorage; } bool ASTWriter::isLookupResultEntirelyExternal(StoredDeclsList &Result, DeclContext *DC) { for (auto *D : Result.getLookupResult()) if (!getDeclForLocalLookup(getLangOpts(), D)->isFromASTFile()) return false; return true; } void ASTWriter::GenerateNameLookupTable(const DeclContext *ConstDC, llvm::SmallVectorImpl &LookupTable) { assert(!ConstDC->HasLazyLocalLexicalLookups && !ConstDC->HasLazyExternalLexicalLookups && "must call buildLookups first"); d3681 1 a3681 1 auto *DC = const_cast(ConstDC); d3684 1 a3684 14 // Create the on-disk hash table representation. MultiOnDiskHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // The first step is to collect the declaration names which we need to // serialize into the name lookup table, and to collect them in a stable // order. SmallVector Names; // We also build up small sets of the constructor and conversion function // names which are visible. llvm::SmallSet ConstructorNameSet, ConversionNameSet; d3686 8 a3693 9 auto &Name = Lookup.first; auto &Result = Lookup.second; // If there are no local declarations in our lookup result, we // don't need to write an entry for the name at all. If we can't // write out a lookup set without performing more deserialization, // just skip this entry. if (isLookupResultExternal(Result, DC) && isLookupResultEntirelyExternal(Result, DC)) d3695 1 d3697 2 a3698 16 // We also skip empty results. If any of the results could be external and // the currently available results are empty, then all of the results are // external and we skip it above. So the only way we get here with an empty // results is when no results could have been external *and* we have // external results. // // FIXME: While we might want to start emitting on-disk entries for negative // lookups into a decl context as an optimization, today we *have* to skip // them because there are names with empty lookup results in decl contexts // which we can't emit in any stable ordering: we lookup constructors and // conversion functions in the enclosing namespace scope creating empty // results for them. This in almost certainly a bug in Clang's name lookup, // but that is likely to be hard or impossible to fix and so we tolerate it // here by omitting lookups with empty results. if (Lookup.second.getLookupResult().empty()) continue; d3700 17 a3716 17 switch (Lookup.first.getNameKind()) { default: Names.push_back(Lookup.first); break; case DeclarationName::CXXConstructorName: assert(isa(DC) && "Cannot have a constructor name outside of a class!"); ConstructorNameSet.insert(Name); break; case DeclarationName::CXXConversionFunctionName: assert(isa(DC) && "Cannot have a conversion function name outside of a class!"); ConversionNameSet.insert(Name); break; } d3718 1 d3720 4 a3723 2 // Sort the names into a stable order. std::sort(Names.begin(), Names.end()); d3725 3 a3727 38 if (auto *D = dyn_cast(DC)) { // We need to establish an ordering of constructor and conversion function // names, and they don't have an intrinsic ordering. // First we try the easy case by forming the current context's constructor // name and adding that name first. This is a very useful optimization to // avoid walking the lexical declarations in many cases, and it also // handles the only case where a constructor name can come from some other // lexical context -- when that name is an implicit constructor merged from // another declaration in the redecl chain. Any non-implicit constructor or // conversion function which doesn't occur in all the lexical contexts // would be an ODR violation. auto ImplicitCtorName = Context->DeclarationNames.getCXXConstructorName( Context->getCanonicalType(Context->getRecordType(D))); if (ConstructorNameSet.erase(ImplicitCtorName)) Names.push_back(ImplicitCtorName); // If we still have constructors or conversion functions, we walk all the // names in the decl and add the constructors and conversion functions // which are visible in the order they lexically occur within the context. if (!ConstructorNameSet.empty() || !ConversionNameSet.empty()) for (Decl *ChildD : cast(DC)->decls()) if (auto *ChildND = dyn_cast(ChildD)) { auto Name = ChildND->getDeclName(); switch (Name.getNameKind()) { default: continue; case DeclarationName::CXXConstructorName: if (ConstructorNameSet.erase(Name)) Names.push_back(Name); break; case DeclarationName::CXXConversionFunctionName: if (ConversionNameSet.erase(Name)) Names.push_back(Name); break; } d3729 3 a3731 23 if (ConstructorNameSet.empty() && ConversionNameSet.empty()) break; } assert(ConstructorNameSet.empty() && "Failed to find all of the visible " "constructors by walking all the " "lexical members of the context."); assert(ConversionNameSet.empty() && "Failed to find all of the visible " "conversion functions by walking all " "the lexical members of the context."); } // Next we need to do a lookup with each name into this decl context to fully // populate any results from external sources. We don't actually use the // results of these lookups because we only want to use the results after all // results have been loaded and the pointers into them will be stable. for (auto &Name : Names) DC->lookup(Name); // Now we need to insert the results for each name into the hash table. For // constructor names and conversion function names, we actually need to merge // all of the results for them into one list of results each and insert // those. d3733 1 a3733 1 SmallVector ConversionDecls; d3735 5 a3739 4 // Now loop over the names, either inserting them or appending for the two // special cases. for (auto &Name : Names) { DeclContext::lookup_result Result = DC->noload_lookup(Name); d3741 3 a3744 4 default: Generator.insert(Name, Trait.getData(Result), Trait); break; d3746 5 d3752 1 a3752 1 break; d3755 2 d3758 3 d3763 18 d3783 6 a3788 14 // Handle our two special cases if we ended up having any. We arbitrarily use // the first declaration's name here because the name itself isn't part of // the key, only the kind of name is used. if (!ConstructorDecls.empty()) Generator.insert(ConstructorDecls.front()->getDeclName(), Trait.getData(ConstructorDecls), Trait); if (!ConversionDecls.empty()) Generator.insert(ConversionDecls.front()->getDeclName(), Trait.getData(ConversionDecls), Trait); // Create the on-disk hash table. Also emit the existing imported and // merged table if there is one. auto *Lookups = Chain ? Chain->getLoadedLookupTables(DC) : nullptr; Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table : nullptr); a3797 49 // If we imported a key declaration of this namespace, write the visible // lookup results as an update record for it rather than including them // on this declaration. We will only look at key declarations on reload. if (isa(DC) && Chain && Chain->getKeyDeclaration(cast(DC))->isFromASTFile()) { // Only do this once, for the first local declaration of the namespace. for (auto *Prev = cast(DC)->getPreviousDecl(); Prev; Prev = Prev->getPreviousDecl()) if (!Prev->isFromASTFile()) return 0; // Note that we need to emit an update record for the primary context. UpdatedDeclContexts.insert(DC->getPrimaryContext()); // Make sure all visible decls are written. They will be recorded later. We // do this using a side data structure so we can sort the names into // a deterministic order. StoredDeclsMap *Map = DC->getPrimaryContext()->buildLookup(); SmallVector, 16> LookupResults; if (Map) { LookupResults.reserve(Map->size()); for (auto &Entry : *Map) LookupResults.push_back( std::make_pair(Entry.first, Entry.second.getLookupResult())); } std::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); for (auto &NameAndResult : LookupResults) { DeclarationName Name = NameAndResult.first; DeclContext::lookup_result Result = NameAndResult.second; if (Name.getNameKind() == DeclarationName::CXXConstructorName || Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { // We have to work around a name lookup bug here where negative lookup // results for these names get cached in namespace lookup tables (these // names should never be looked up in a namespace). assert(Result.empty() && "Cannot have a constructor or conversion " "function name in a namespace!"); continue; } for (NamedDecl *ND : Result) if (!ND->isFromASTFile()) GetDeclRef(ND); } return 0; } d3801 3 a3803 2 // Skip contexts which don't support name lookup. if (!DC->isLookupContext()) d3823 1 a3823 1 GenerateNameLookupTable(DC, LookupTable); d3826 3 a3828 1 RecordData::value_type Record[] = {DECL_CONTEXT_VISIBLE}; d3830 1 a3830 1 LookupTable); d3848 1 a3848 6 GenerateNameLookupTable(DC, LookupTable); // If we're updating a namespace, select a key declaration as the key for the // update record; those are the only ones that will be checked on reload. if (isa(DC)) DC = cast(Chain->getKeyDeclaration(cast(DC))); d3851 5 a3855 2 RecordData::value_type Record[] = {UPDATE_VISIBLE, getDeclID(cast(DC))}; Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable); d3860 2 a3861 1 RecordData::value_type Record[] = {Opts.fp_contract}; d3877 81 d3994 1 a3994 2 auto *Abbrev = new BitCodeAbbrev(); d3999 6 a4004 4 RecordData::value_type Record[] = {OBJC_CATEGORIES_MAP, CategoriesMap.size()}; Stream.EmitRecordWithBlob(AbbrevID, Record, reinterpret_cast(CategoriesMap.data()), d4006 1 a4006 1 d4011 19 d4037 5 a4041 4 for (auto LPTMapEntry : LPTMap) { const FunctionDecl *FD = LPTMapEntry.first; LateParsedTemplate *LPT = LPTMapEntry.second; AddDeclRef(FD, Record); d4045 4 a4048 2 for (const auto &Tok : LPT->Toks) { AddToken(Tok, Record); a4061 35 void ASTWriter::WriteModuleFileExtension(Sema &SemaRef, ModuleFileExtensionWriter &Writer) { // Enter the extension block. Stream.EnterSubblock(EXTENSION_BLOCK_ID, 4); // Emit the metadata record abbreviation. auto *Abv = new llvm::BitCodeAbbrev(); Abv->Add(llvm::BitCodeAbbrevOp(EXTENSION_METADATA)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); unsigned Abbrev = Stream.EmitAbbrev(Abv); // Emit the metadata record. RecordData Record; auto Metadata = Writer.getExtension()->getExtensionMetadata(); Record.push_back(EXTENSION_METADATA); Record.push_back(Metadata.MajorVersion); Record.push_back(Metadata.MinorVersion); Record.push_back(Metadata.BlockName.size()); Record.push_back(Metadata.UserInfo.size()); SmallString<64> Buffer; Buffer += Metadata.BlockName; Buffer += Metadata.UserInfo; Stream.EmitRecordWithBlob(Abbrev, Record, Buffer); // Emit the contents of the extension block. Writer.writeExtensionContents(SemaRef, Stream); // Exit the extension block. Stream.ExitBlock(); } d4070 3 a4072 1 for (const auto *A : Attrs) { d4123 1 a4123 1 void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, d4165 1 a4165 4 ASTWriter::ASTWriter( llvm::BitstreamWriter &Stream, ArrayRef> Extensions, bool IncludeTimestamps) d4167 7 a4173 7 WritingModule(nullptr), IncludeTimestamps(IncludeTimestamps), WritingAST(false), DoneWritingDeclsAndTypes(false), ASTHasCompilerErrors(false), FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID), FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), d4178 2 a4179 2 NextCXXBaseSpecifiersID(1), NextCXXCtorInitializersID(1), TypeExtQualAbbrev(0), TypeFunctionProtoAbbrev(0), DeclParmVarAbbrev(0), d4185 1 a4185 6 ExprImplicitCastAbbrev(0) { for (const auto &Ext : Extensions) { if (auto Writer = Ext->createExtensionWriter(*this)) ModuleFileExtensionWriters.push_back(std::move(Writer)); } } d4191 4 a4194 12 const LangOptions &ASTWriter::getLangOpts() const { assert(WritingAST && "can't determine lang opts when not writing AST"); return Context->getLangOpts(); } time_t ASTWriter::getTimestampForOutput(const FileEntry *E) const { return IncludeTimestamps ? E->getModificationTime() : 0; } uint64_t ASTWriter::WriteAST(Sema &SemaRef, const std::string &OutputFile, Module *WritingModule, StringRef isysroot, bool hasErrors) { d4196 1 a4196 1 d4210 1 a4210 2 ASTFileSignature Signature = WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule); a4216 1 return Signature; d4228 4 a4231 3 uint64_t ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, const std::string &OutputFile, Module *WritingModule) { d4244 47 a4290 4 auto RegisterPredefDecl = [&] (Decl *D, PredefinedDeclIDs ID) { if (D) { assert(D->isCanonicalDecl() && "predefined decl is not canonical"); DeclIDs[D] = ID; d4292 10 a4301 19 }; RegisterPredefDecl(Context.getTranslationUnitDecl(), PREDEF_DECL_TRANSLATION_UNIT_ID); RegisterPredefDecl(Context.ObjCIdDecl, PREDEF_DECL_OBJC_ID_ID); RegisterPredefDecl(Context.ObjCSelDecl, PREDEF_DECL_OBJC_SEL_ID); RegisterPredefDecl(Context.ObjCClassDecl, PREDEF_DECL_OBJC_CLASS_ID); RegisterPredefDecl(Context.ObjCProtocolClassDecl, PREDEF_DECL_OBJC_PROTOCOL_ID); RegisterPredefDecl(Context.Int128Decl, PREDEF_DECL_INT_128_ID); RegisterPredefDecl(Context.UInt128Decl, PREDEF_DECL_UNSIGNED_INT_128_ID); RegisterPredefDecl(Context.ObjCInstanceTypeDecl, PREDEF_DECL_OBJC_INSTANCETYPE_ID); RegisterPredefDecl(Context.BuiltinVaListDecl, PREDEF_DECL_BUILTIN_VA_LIST_ID); RegisterPredefDecl(Context.VaListTagDecl, PREDEF_DECL_VA_LIST_TAG); RegisterPredefDecl(Context.BuiltinMSVaListDecl, PREDEF_DECL_BUILTIN_MS_VA_LIST_ID); RegisterPredefDecl(Context.ExternCContext, PREDEF_DECL_EXTERN_C_CONTEXT_ID); RegisterPredefDecl(Context.MakeIntegerSeqDecl, PREDEF_DECL_MAKE_INTEGER_SEQ_ID); d4325 9 a4333 7 for (auto &WeakUndeclaredIdentifier : SemaRef.WeakUndeclaredIdentifiers) { IdentifierInfo *II = WeakUndeclaredIdentifier.first; WeakInfo &WI = WeakUndeclaredIdentifier.second; AddIdentifierRef(II, WeakUndeclaredIdentifiers); AddIdentifierRef(WI.getAlias(), WeakUndeclaredIdentifiers); AddSourceLocation(WI.getLocation(), WeakUndeclaredIdentifiers); WeakUndeclaredIdentifiers.push_back(WI.getUsed()); d4336 14 d4369 4 d4375 5 a4379 3 for (const auto &I : SemaRef.PendingInstantiations) { AddDeclRef(I.first, PendingInstantiations); AddSourceLocation(I.second, PendingInstantiations); d4398 6 a4403 3 for (const auto &I : SemaRef.KnownNamespaces) { if (!I.second) AddDeclRef(I.first, KnownNamespaces); d4411 4 a4414 17 for (const auto &I : Undefined) { AddDeclRef(I.first, UndefinedButUsed); AddSourceLocation(I.second, UndefinedButUsed); } // Build a record containing all delete-expressions that we would like to // analyze later in AST. RecordData DeleteExprsToAnalyze; for (const auto &DeleteExprsInfo : SemaRef.getMismatchingDeleteExpressions()) { AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size()); for (const auto &DeleteLoc : DeleteExprsInfo.second) { AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteLoc.second); } d4418 1 a4418 1 uint64_t Signature = WriteControlBlock(PP, Context, isysroot, OutputFile); d4421 1 d4426 3 a4428 4 { RecordData Record = {VERSION_MAJOR}; Stream.EmitRecord(METADATA_OLD_FORMAT, Record); } d4433 4 a4436 6 SmallVector NewGlobalKindDeclPairs; for (const auto *D : TU->noload_decls()) { if (!D->isFromASTFile()) { NewGlobalKindDeclPairs.push_back(D->getKind()); NewGlobalKindDeclPairs.push_back(GetDeclRef(D)); } d4439 1 a4439 1 auto *Abv = new llvm::BitCodeAbbrev(); d4443 5 a4447 6 { RecordData::value_type Record[] = {TU_UPDATE_LEXICAL}; Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, bytes(NewGlobalKindDeclPairs)); } d4452 1 a4455 4 // If we have any extern "C" names, write out a visible update for them. if (Context.ExternCContext) WriteDeclContextVisibleUpdate(Context.ExternCContext); d4480 4 a4483 2 for (const auto *I : UpdatingVisibleDecls) { GetDeclRef(I); d4487 6 a4492 11 // serialization, if we're storing decls with identifiers. if (!WritingModule || !getLangOpts().CPlusPlus) { llvm::SmallVector IIs; for (const auto &ID : PP.getIdentifierTable()) { const IdentifierInfo *II = ID.second; if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) IIs.push_back(II); } // Sort the identifiers to visit based on their name. std::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); for (const IdentifierInfo *II : IIs) { d4528 1 a4528 1 auto *Abbrev = new BitCodeAbbrev(); d4567 2 a4568 1 RecordData::value_type Record[] = {MODULE_OFFSET_MAP}; d4580 4 a4603 1 WriteCXXCtorInitializersOffsets(); d4606 1 a4611 1 WriteLateParsedTemplates(SemaRef); d4640 5 d4653 4 d4685 1 a4685 4 if (!DeleteExprsToAnalyze.empty()) Stream.EmitRecord(DELETE_EXPRS_TO_ANALYZE, DeleteExprsToAnalyze); d4723 1 a4723 1 AddSourceLocation(PP.getModuleImportLoc(Import.M), ImportedModules); d4731 2 d4734 1 d4739 5 a4743 2 RecordData::value_type Record[] = { NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts}; a4745 6 // Write the module file extension blocks. for (const auto &ExtWriter : ModuleFileExtensionWriters) WriteModuleFileExtension(SemaRef, *ExtWriter); return Signature; d4757 2 a4784 5 case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: AddStmt(const_cast( cast(Update.getDecl())->getDefaultArg())); break; d4787 1 a4787 1 UpdatedDeclContexts.insert(RD->getPrimaryContext()); a4830 4 case UPD_CXX_RESOLVED_DTOR_DELETE: AddDeclRef(Update.getDecl(), Record); break; a4848 1 a4852 8 case UPD_DECL_EXPORTED: Record.push_back(getSubmoduleID(Update.getModule())); break; case UPD_ADDED_ATTR_TO_RECORD: WriteAttributes(llvm::makeArrayRef(Update.getAttr()), Record); break; d4857 1 a4857 1 const auto *Def = cast(D); d4862 2 d4871 5 a4875 1 FlushPendingAfterDecl(); d4884 5 a4888 4 for (const auto &I : ReplacedDecls) { Record.push_back(I.ID); Record.push_back(I.Offset); Record.push_back(I.Loc); d4956 2 a4957 1 return IdentMacroDirectivesOffsetMap.lookup(Name); a4986 8 void ASTWriter::AddCXXCtorInitializersRef(ArrayRef Inits, RecordDataImpl &Record) { assert(!Inits.empty() && "Empty ctor initializer sets are not recorded"); CXXCtorInitializersToWrite.push_back( QueuedCXXCtorInitializers(NextCXXCtorInitializersID, Inits)); Record.push_back(NextCXXCtorInitializersID++); } d4988 1 a4988 1 CXXBaseSpecifier const *BasesEnd, d5063 1 a5063 1 TypeID ASTWriter::GetOrCreateTypeID(QualType T) { d5065 9 a5073 4 return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); d5075 4 a5078 6 TypeIdx &Idx = TypeIdxs[T]; if (Idx.getIndex() == 0) { if (DoneWritingDeclsAndTypes) { assert(0 && "New type seen after serializing all the types to emit!"); return TypeIdx(); } d5080 5 a5084 4 // We haven't seen this type before. Assign it a new ID and put it // into the queue of types to emit. Idx = TypeIdx(NextTypeID++); DeclTypesToEmit.push(T); d5086 7 a5092 2 return Idx; }); d5095 4 a5098 6 TypeID ASTWriter::getTypeID(QualType T) const { assert(Context); return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); d5100 3 a5102 4 TypeIdxMap::const_iterator I = TypeIdxs.find(T); assert(I != TypeIdxs.end() && "Type not emitted!"); return I->second; }); d5237 7 a5243 4 auto *DC = D->getLexicalDeclContext(); numberAnonymousDeclsWithin(DC, [&](const NamedDecl *ND, unsigned Number) { AnonymousDeclarationNumbers[ND] = Number; }); d5413 3 a5415 2 for (const auto &I : *OvT) AddDeclRef(I, Record); d5505 4 a5508 2 for (const auto &P : *TemplateParams) AddDeclRef(P, Record); d5558 1 a5558 2 unsigned N = CXXBaseSpecifiersToWrite.size(); for (unsigned I = 0; I != N; ++I) { a5581 2 assert(N == CXXBaseSpecifiersToWrite.size() && "added more base specifiers while writing base specifiers"); a5622 30 void ASTWriter::FlushCXXCtorInitializers() { RecordData Record; unsigned N = CXXCtorInitializersToWrite.size(); (void)N; // Silence unused warning in non-assert builds. for (auto &Init : CXXCtorInitializersToWrite) { Record.clear(); // Record the offset of this mem-initializer list. unsigned Index = Init.ID - 1; if (Index == CXXCtorInitializersOffsets.size()) CXXCtorInitializersOffsets.push_back(Stream.GetCurrentBitNo()); else { if (Index > CXXCtorInitializersOffsets.size()) CXXCtorInitializersOffsets.resize(Index + 1); CXXCtorInitializersOffsets[Index] = Stream.GetCurrentBitNo(); } AddCXXCtorInitializers(Init.Inits.data(), Init.Inits.size(), Record); Stream.EmitRecord(serialization::DECL_CXX_CTOR_INITIALIZERS, Record); // Flush any expressions that were written as part of the initializers. FlushStmts(); } assert(N == CXXCtorInitializersToWrite.size() && "added more ctor initializers while writing ctor initializers"); CXXCtorInitializersToWrite.clear(); } a5727 2 // Note, this will get called multiple times, once one the reader starts up // and again each time it's done reading a PCH or module. d5775 1 a5775 1 MacroDefinitionRecord *MD) { d5788 1 a5788 1 if (auto *RD = dyn_cast(D)) { a5801 13 static bool isImportedDeclContext(ASTReader *Chain, const Decl *D) { if (D->isFromASTFile()) return true; // If we've not loaded any modules, this can't be imported. if (!Chain || !Chain->getModuleManager().size()) return false; // The predefined __va_list_tag struct is imported if we imported any decls. // FIXME: This is a gross hack. return D == D->getASTContext().getVaListTagDecl(); } d5807 2 a5808 4 // We're only interested in cases where a local declaration is added to an // imported context. if (D->isFromASTFile() || !isImportedDeclContext(Chain, cast(DC))) return; a5809 1 assert(DC == DC->getPrimaryContext() && "added to non-primary context"); d5812 1 a5812 7 if (UpdatedDeclContexts.insert(DC) && !cast(DC)->isFromASTFile()) { // We're adding a visible declaration to a predefined decl context. Ensure // that we write out all of its lookup results so we don't get a nasty // surprise when we try to emit its lookup table. for (auto *Child : DC->decls()) UpdatingVisibleDecls.push_back(Child); } d5818 2 a5819 6 // We're only interested in cases where a local declaration is added to an // imported context. if (D->isFromASTFile() || !isImportedDeclContext(Chain, RD)) return; d5821 1 a5821 1 return; d5829 36 d5866 6 a5871 11 assert(!DoneWritingDeclsAndTypes && "Already done writing updates!"); if (!Chain) return; Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { // If we don't already know the exception specification for this redecl // chain, add an update record for it. if (isUnresolvedExceptionSpec(cast(D) ->getType() ->castAs() ->getExceptionSpecType())) DeclUpdates[D].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC); }); d5876 3 a5878 6 if (!Chain) return; Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType)); }); } d5880 1 a5880 8 void ASTWriter::ResolvedOperatorDelete(const CXXDestructorDecl *DD, const FunctionDecl *Delete) { assert(!WritingAST && "Already writing the AST!"); assert(Delete && "Not given an operator delete"); if (!Chain) return; Chain->forEachImportedKeyDecl(DD, [&](const Decl *D) { DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_RESOLVED_DTOR_DELETE, Delete)); }); d5897 2 a5898 1 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); a5912 9 void ASTWriter::DefaultArgumentInstantiated(const ParmVarDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT, D)); } d5924 15 a5953 14 void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) { assert(!WritingAST && "Already writing the AST!"); assert(D->isHidden() && "expected a hidden declaration"); DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_EXPORTED, M)); } void ASTWriter::AddedAttributeToRecord(const Attr *Attr, const RecordDecl *Record) { assert(!WritingAST && "Already writing the AST!"); if (!Record->isFromASTFile()) return; DeclUpdates[Record].push_back(DeclUpdate(UPD_ADDED_ATTR_TO_RECORD, Attr)); } @ 1.1.1.9.2.1 log @Sync with HEAD @ text @d15 1 a19 1 #include "clang/AST/ASTUnresolvedSet.h" a21 1 #include "clang/AST/DeclCXX.h" d23 1 a26 4 #include "clang/AST/LambdaCapture.h" #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/RawCommentList.h" #include "clang/AST/TemplateName.h" d31 1 a31 5 #include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/Module.h" #include "clang/Basic/ObjCRuntime.h" a40 1 #include "clang/Lex/ModuleMap.h" a43 1 #include "clang/Lex/Token.h" a44 1 #include "clang/Sema/ObjCMethodList.h" a45 1 #include "clang/Sema/Weak.h" a46 2 #include "clang/Serialization/Module.h" #include "clang/Serialization/ModuleFileExtension.h" a50 5 #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/STLExtras.h" a51 1 #include "llvm/Bitcode/BitCodes.h" a52 2 #include "llvm/Support/Casting.h" #include "llvm/Support/Compression.h" d54 1 a54 1 #include "llvm/Support/ErrorHandling.h" a58 1 #include "llvm/Support/raw_ostream.h" d60 2 a61 8 #include #include #include #include #include #include #include #include d84 1 a84 2 namespace clang { d87 1 a87 1 ASTRecordWriter Record; d89 1 a94 1 public: d96 1 a96 24 : Writer(Writer), Record(Writer, Record), Code((TypeCode)0), AbbrevToUse(0) { } uint64_t Emit() { return Record.Emit(Code, AbbrevToUse); } void Visit(QualType T) { if (T.hasLocalNonFastQualifiers()) { Qualifiers Qs = T.getLocalQualifiers(); Record.AddTypeRef(T.getLocalUnqualifiedType()); Record.push_back(Qs.getAsOpaqueValue()); Code = TYPE_EXT_QUAL; AbbrevToUse = Writer.TypeExtQualAbbrev; } else { switch (T->getTypeClass()) { // For all of the concrete, non-dependent types, call the // appropriate visitor function. #define TYPE(Class, Base) \ case Type::Class: Visit##Class##Type(cast(T)); break; #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" } } } d106 1 a106 2 } // end namespace clang d113 1 a113 1 Record.AddTypeRef(T->getElementType()); d118 1 a118 1 Record.AddTypeRef(T->getPointeeType()); d123 1 a123 1 Record.AddTypeRef(T->getOriginalType()); d128 2 a129 2 Record.AddTypeRef(T->getOriginalType()); Record.AddTypeRef(T->getAdjustedType()); d134 1 a134 1 Record.AddTypeRef(T->getPointeeType()); d139 1 a139 1 Record.AddTypeRef(T->getPointeeTypeAsWritten()); d145 1 a145 1 Record.AddTypeRef(T->getPointeeTypeAsWritten()); d150 2 a151 2 Record.AddTypeRef(T->getPointeeType()); Record.AddTypeRef(QualType(T->getClass(), 0)); d156 1 a156 1 Record.AddTypeRef(T->getElementType()); d163 1 a163 1 Record.AddAPInt(T->getSize()); d174 3 a176 3 Record.AddSourceLocation(T->getLBracketLoc()); Record.AddSourceLocation(T->getRBracketLoc()); Record.AddStmt(T->getSizeExpr()); d181 1 a181 1 Record.AddTypeRef(T->getElementType()); d193 1 a193 1 Record.AddTypeRef(T->getReturnType()); d211 2 a212 2 static void addExceptionSpec(const FunctionProtoType *T, ASTRecordWriter &Record) { d217 1 a217 1 Record.AddTypeRef(T->getExceptionType(I)); d219 1 a219 1 Record.AddStmt(T->getNoexceptExpr()); d221 2 a222 2 Record.AddDeclRef(T->getExceptionSpecDecl()); Record.AddDeclRef(T->getExceptionSpecTemplate()); d224 1 a224 1 Record.AddDeclRef(T->getExceptionSpecDecl()); d235 1 a235 1 addExceptionSpec(T, Record); d239 1 a239 6 Record.AddTypeRef(T->getParamType(I)); if (T->hasExtParameterInfos()) { for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Record.push_back(T->getExtParameterInfo(I).getOpaqueValue()); } d242 1 a242 2 T->getRefQualifier() || T->getExceptionSpecType() != EST_None || T->hasExtParameterInfos()) d249 1 a249 1 Record.AddDeclRef(T->getDecl()); d254 1 a254 1 Record.AddDeclRef(T->getDecl()); d256 1 a256 1 Record.AddTypeRef(T->getCanonicalTypeInternal()); d261 1 a261 1 Record.AddStmt(T->getUnderlyingExpr()); d266 1 a266 1 Record.AddTypeRef(T->getUnderlyingType()); d271 2 a272 2 Record.AddTypeRef(T->getUnderlyingType()); Record.AddStmt(T->getUnderlyingExpr()); d277 2 a278 2 Record.AddTypeRef(T->getBaseType()); Record.AddTypeRef(T->getUnderlyingType()); d284 1 a284 1 Record.AddTypeRef(T->getDeducedType()); d293 1 a293 1 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); d309 2 a310 2 Record.AddTypeRef(T->getModifiedType()); Record.AddTypeRef(T->getEquivalentType()); d318 2 a319 2 Record.AddTypeRef(QualType(T->getReplacedParameter(), 0)); Record.AddTypeRef(T->getReplacementType()); d326 2 a327 2 Record.AddTypeRef(QualType(T->getReplacedParameter(), 0)); Record.AddTemplateArgument(T->getArgumentPack()); d335 1 a335 1 Record.AddTemplateName(T->getTemplateName()); d338 5 a342 5 Record.AddTemplateArgument(ArgI); Record.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() : T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal()); d349 2 a350 2 Record.AddStmt(T->getSizeExpr()); Record.AddSourceRange(T->getBracketsRange()); d366 1 a366 1 Record.AddDeclRef(T->getDecl()); d373 5 a377 4 Record.AddNestedNameSpecifier(T->getQualifier()); Record.AddIdentifierRef(T->getIdentifier()); Record.AddTypeRef( T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal()); d385 2 a386 2 Record.AddNestedNameSpecifier(T->getQualifier()); Record.AddIdentifierRef(T->getIdentifier()); d389 1 a389 1 Record.AddTemplateArgument(I); d394 1 a394 1 Record.AddTypeRef(T->getPattern()); d403 1 a403 1 Record.AddTypeRef(T->getInnerType()); d409 2 a410 2 Record.AddNestedNameSpecifier(T->getQualifier()); Record.AddTypeRef(T->getNamedType()); d415 2 a416 2 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); Record.AddTypeRef(T->getInjectedSpecializationType()); d421 1 a421 1 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); a424 8 void ASTTypeWriter::VisitObjCTypeParamType(const ObjCTypeParamType *T) { Record.AddDeclRef(T->getDecl()); Record.push_back(T->getNumProtocols()); for (const auto *I : T->quals()) Record.AddDeclRef(I); Code = TYPE_OBJC_TYPE_PARAM; } d426 1 a426 1 Record.AddTypeRef(T->getBaseType()); d429 1 a429 1 Record.AddTypeRef(TypeArg); d432 1 a432 1 Record.AddDeclRef(I); d439 1 a439 1 Record.AddTypeRef(T->getPointeeType()); d445 1 a445 1 Record.AddTypeRef(T->getValueType()); d451 1 a451 2 Record.AddTypeRef(T->getElementType()); Record.push_back(T->isReadOnly()); d458 2 a459 1 ASTRecordWriter &Record; d462 2 a463 2 TypeLocWriter(ASTRecordWriter &Record) : Record(Record) { } a478 1 d480 1 a480 1 Record.AddSourceLocation(TL.getBuiltinLoc()); a487 1 d489 1 a489 1 Record.AddSourceLocation(TL.getNameLoc()); a490 1 d492 1 a492 1 Record.AddSourceLocation(TL.getStarLoc()); a493 1 a496 1 a499 1 d501 1 a501 1 Record.AddSourceLocation(TL.getCaretLoc()); a502 1 d504 1 a504 1 Record.AddSourceLocation(TL.getAmpLoc()); a505 1 d507 1 a507 1 Record.AddSourceLocation(TL.getAmpAmpLoc()); a508 1 d510 2 a511 2 Record.AddSourceLocation(TL.getStarLoc()); Record.AddTypeSourceInfo(TL.getClassTInfo()); a512 1 d514 2 a515 2 Record.AddSourceLocation(TL.getLBracketLoc()); Record.AddSourceLocation(TL.getRBracketLoc()); d518 1 a518 1 Record.AddStmt(TL.getSizeExpr()); a519 1 a522 1 a525 1 a528 1 a532 1 d535 1 a535 1 Record.AddSourceLocation(TL.getNameLoc()); a536 1 d538 1 a538 1 Record.AddSourceLocation(TL.getNameLoc()); a539 1 d541 1 a541 1 Record.AddSourceLocation(TL.getNameLoc()); a542 1 d544 4 a547 5 Record.AddSourceLocation(TL.getLocalRangeBegin()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); Record.AddSourceRange(TL.getExceptionSpecRange()); Record.AddSourceLocation(TL.getLocalRangeEnd()); d549 1 a549 1 Record.AddDeclRef(TL.getParam(i)); d558 1 a558 1 Record.AddSourceLocation(TL.getNameLoc()); d561 1 a561 9 Record.AddSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { if (TL.getNumProtocols()) { Record.AddSourceLocation(TL.getProtocolLAngleLoc()); Record.AddSourceLocation(TL.getProtocolRAngleLoc()); } for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) Record.AddSourceLocation(TL.getProtocolLoc(i)); d564 3 a566 3 Record.AddSourceLocation(TL.getTypeofLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); a567 1 d569 4 a572 4 Record.AddSourceLocation(TL.getTypeofLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); a573 1 d575 1 a575 1 Record.AddSourceLocation(TL.getNameLoc()); a576 1 d578 4 a581 4 Record.AddSourceLocation(TL.getKWLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); a582 1 d584 1 a584 1 Record.AddSourceLocation(TL.getNameLoc()); a585 1 d587 1 a587 1 Record.AddSourceLocation(TL.getNameLoc()); a588 1 d590 1 a590 1 Record.AddSourceLocation(TL.getNameLoc()); a591 1 d593 1 a593 1 Record.AddSourceLocation(TL.getAttrNameLoc()); d596 2 a597 2 Record.AddSourceLocation(range.getBegin()); Record.AddSourceLocation(range.getEnd()); d602 1 a602 1 if (operand) Record.AddStmt(operand); d604 1 a604 1 Record.AddSourceLocation(TL.getAttrEnumOperandLoc()); a606 1 d608 1 a608 1 Record.AddSourceLocation(TL.getNameLoc()); a609 1 d612 1 a612 1 Record.AddSourceLocation(TL.getNameLoc()); a613 1 d616 1 a616 1 Record.AddSourceLocation(TL.getNameLoc()); a617 1 d620 4 a623 4 Record.AddSourceLocation(TL.getTemplateKeywordLoc()); Record.AddSourceLocation(TL.getTemplateNameLoc()); Record.AddSourceLocation(TL.getLAngleLoc()); Record.AddSourceLocation(TL.getRAngleLoc()); d625 2 a626 2 Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), TL.getArgLoc(i).getLocInfo()); a627 1 d629 2 a630 2 Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); a631 1 d633 2 a634 2 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); a635 1 d637 1 a637 1 Record.AddSourceLocation(TL.getNameLoc()); a638 1 d640 3 a642 3 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); Record.AddSourceLocation(TL.getNameLoc()); a643 1 d646 6 a651 6 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); Record.AddSourceLocation(TL.getTemplateKeywordLoc()); Record.AddSourceLocation(TL.getTemplateNameLoc()); Record.AddSourceLocation(TL.getLAngleLoc()); Record.AddSourceLocation(TL.getRAngleLoc()); d653 2 a654 2 Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), TL.getArgLoc(I).getLocInfo()); a655 1 d657 1 a657 1 Record.AddSourceLocation(TL.getEllipsisLoc()); a658 1 d660 1 a660 1 Record.AddSourceLocation(TL.getNameLoc()); a661 1 d664 2 a665 2 Record.AddSourceLocation(TL.getTypeArgsLAngleLoc()); Record.AddSourceLocation(TL.getTypeArgsRAngleLoc()); d667 3 a669 3 Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i)); Record.AddSourceLocation(TL.getProtocolLAngleLoc()); Record.AddSourceLocation(TL.getProtocolRAngleLoc()); d671 1 a671 1 Record.AddSourceLocation(TL.getProtocolLoc(i)); a672 1 d674 1 a674 1 Record.AddSourceLocation(TL.getStarLoc()); a675 1 d677 3 a679 3 Record.AddSourceLocation(TL.getKWLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); a680 1 d682 1 a682 1 Record.AddSourceLocation(TL.getKWLoc()); d688 1 a688 1 std::shared_ptr Abv; d691 1 a691 1 Abv = std::make_shared(); d695 1 a695 1 TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv)); d698 1 a698 1 Abv = std::make_shared(); d716 1 a716 1 TypeFunctionProtoAbbrev = Stream.EmitAbbrev(std::move(Abv)); d880 1 a880 1 Stream.EnterBlockInfoBlock(); d933 1 d937 1 a942 2 RECORD(OPENCL_EXTENSION_TYPES); RECORD(OPENCL_EXTENSION_DECLS); a955 2 RECORD(MSSTRUCT_PRAGMA_OPTIONS); RECORD(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS); d957 1 a958 1 RECORD(CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH); a964 1 RECORD(SM_SLOC_BUFFER_BLOB_COMPRESSED); a992 1 RECORD(SUBMODULE_INITIALIZERS); a1040 1 RECORD(TYPE_OBJC_TYPE_PARAM); a1078 1 RECORD(DECL_CXX_INHERITED_CONSTRUCTOR); a1093 1 RECORD(DECL_TYPE_ALIAS_TEMPLATE); a1095 1 RECORD(DECL_CXX_CTOR_INITIALIZERS); a1097 10 RECORD(DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK); RECORD(DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION); RECORD(DECL_IMPORT); RECORD(DECL_OMP_THREADPRIVATE); RECORD(DECL_EMPTY); RECORD(DECL_OBJC_TYPE_PARAM); RECORD(DECL_OMP_CAPTUREDEXPR); RECORD(DECL_PRAGMA_COMMENT); RECORD(DECL_PRAGMA_DETECT_MISMATCH); RECORD(DECL_OMP_DECLARE_REDUCTION); d1174 1 a1174 1 while (true) { d1193 1 a1193 1 auto MetadataAbbrev = std::make_shared(); d1203 1 a1203 1 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev)); d1226 1 a1226 1 auto Abbrev = std::make_shared(); d1229 1 a1229 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); d1246 1 a1246 1 auto Abbrev = std::make_shared(); d1249 1 a1249 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); d1456 1 a1456 1 auto FileAbbrev = std::make_shared(); d1460 1 a1460 1 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev)); d1474 1 a1474 1 auto Abbrev = std::make_shared(); d1477 1 a1477 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); a1495 1 a1502 1 d1512 1 a1512 1 auto IFAbbrev = std::make_shared(); d1520 1 a1520 1 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev)); d1580 1 a1580 1 auto OffsetsAbbrev = std::make_shared(); d1586 1 a1586 1 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev)); d1603 1 a1603 1 auto Abbrev = std::make_shared(); d1614 1 a1614 1 return Stream.EmitAbbrev(std::move(Abbrev)); d1622 1 a1622 1 auto Abbrev = std::make_shared(); d1629 1 a1629 1 return Stream.EmitAbbrev(std::move(Abbrev)); d1634 1 a1634 2 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream, bool Compressed) { d1637 2 a1638 5 auto Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED : SM_SLOC_BUFFER_BLOB)); if (Compressed) Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Uncompressed size d1640 1 a1640 1 return Stream.EmitAbbrev(std::move(Abbrev)); d1648 1 a1648 1 auto Abbrev = std::make_shared(); d1655 1 a1655 1 return Stream.EmitAbbrev(std::move(Abbrev)); a1658 1 d1674 1 a1674 1 StringRef Filename; d1695 1 a1695 1 unsigned KeyLen = key.Filename.size() + 1 + 8 + 8; d1712 1 a1712 1 Out.write(key.Filename.data(), KeyLen); a1766 1 d1800 1 a1800 1 StringRef Filename = File->getName(); d1805 2 a1806 2 Filename = StringRef(strdup(FilenameTmp.c_str())); SavedStrings.push_back(Filename.data()); d1828 1 a1828 1 auto Abbrev = std::make_shared(); d1834 1 a1834 1 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d1860 1 a1860 1 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 4); d1865 1 a1865 3 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false); unsigned SLocBufferBlobCompressedAbbrv = CreateSLocBufferBlobAbbrev(Stream, true); d1900 1 a1900 1 AddSourceLocation(File.getIncludeLoc(), Record); a1904 1 bool EmitBlob = false; d1926 8 a1933 2 if (Content->BufferOverridden || Content->IsTransient) EmitBlob = true; d1943 1 a1943 1 StringRef Name = Buffer->getBufferIdentifier(); d1945 5 a1949 2 StringRef(Name.data(), Name.size() + 1)); EmitBlob = true; d1951 1 a1951 1 if (Name == "") a1952 21 } if (EmitBlob) { // Include the implicit terminating null character in the on-disk buffer // if we're writing it uncompressed. const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1); // Compress the buffer if possible. We expect that almost all PCM // consumers will not want its contents. SmallString<0> CompressedBuffer; if (llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer) == llvm::zlib::StatusOK) { RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1}; Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, CompressedBuffer); } else { RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB}; Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob); d1958 4 a1961 6 AddSourceLocation(Expansion.getSpellingLoc(), Record); AddSourceLocation(Expansion.getExpansionLocStart(), Record); AddSourceLocation(Expansion.isMacroArgExpansion() ? SourceLocation() : Expansion.getExpansionLocEnd(), Record); d1981 1 a1981 1 auto Abbrev = std::make_shared(); d1986 1 a1986 1 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2128 21 a2148 21 // We write out exported module macros for PCH as well. auto Leafs = PP.getLeafModuleMacros(Name); SmallVector Worklist(Leafs.begin(), Leafs.end()); llvm::DenseMap Visits; while (!Worklist.empty()) { auto *Macro = Worklist.pop_back_val(); // Emit a record indicating this submodule exports this macro. ModuleMacroRecord.push_back( getSubmoduleID(Macro->getOwningModule())); ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name)); for (auto *M : Macro->overrides()) ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule())); Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); ModuleMacroRecord.clear(); // Enqueue overridden macros once we've visited all their ancestors. for (auto *M : Macro->overrides()) if (++Visits[M] == M->getNumOverridingMacros()) Worklist.push_back(M); d2150 2 a2151 1 EmittedModuleMacros = true; d2237 1 a2237 1 auto Abbrev = std::make_shared(); d2243 1 a2243 1 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2267 1 a2267 1 auto Abbrev = std::make_shared(); d2274 1 a2274 1 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2337 1 a2337 1 auto Abbrev = std::make_shared(); d2341 1 a2341 1 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2359 1 a2359 3 auto *Top = Mod->getTopLevelModule(); if (Top != WritingModule && !Top->fullModuleNameIs(StringRef(getLangOpts().CurrentModule))) d2393 1 a2393 1 auto Abbrev = std::make_shared(); d2406 1 a2406 1 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2408 1 a2408 1 Abbrev = std::make_shared(); d2411 1 a2411 1 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2413 1 a2413 1 Abbrev = std::make_shared(); d2416 1 a2416 1 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2418 1 a2418 1 Abbrev = std::make_shared(); d2421 1 a2421 1 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2423 1 a2423 1 Abbrev = std::make_shared(); d2426 1 a2426 1 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2428 1 a2428 1 Abbrev = std::make_shared(); d2432 1 a2432 1 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2434 1 a2434 1 Abbrev = std::make_shared(); d2437 1 a2437 1 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2439 1 a2439 1 Abbrev = std::make_shared(); d2442 1 a2442 1 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2444 1 a2444 1 Abbrev = std::make_shared(); d2447 1 a2447 1 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2449 1 a2449 1 Abbrev = std::make_shared(); d2452 1 a2452 1 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2454 1 a2454 1 Abbrev = std::make_shared(); d2458 1 a2458 1 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2460 1 a2460 1 Abbrev = std::make_shared(); d2463 1 a2463 1 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2465 1 a2465 1 Abbrev = std::make_shared(); d2469 1 a2469 1 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); a2590 7 // Emit the initializers, if any. RecordData Inits; for (Decl *D : Context->getModuleInitializers(Mod)) Inits.push_back(GetDeclRef(D)); if (!Inits.empty()) Stream.EmitRecord(SUBMODULE_INITIALIZERS, Inits); d2643 1 a2643 1 AddSourceLocation(point.Loc, Record); d2664 40 d2710 3 a2712 4 TypeIdx &IdxRef = TypeIdxs[T]; if (IdxRef.getIndex() == 0) // we haven't seen this type before. IdxRef = TypeIdx(NextTypeID++); TypeIdx Idx = IdxRef; d2716 9 d2729 1 a2729 2 W.Visit(T); uint64_t Offset = W.Emit(); d2731 6 a2736 7 // Record the offset for this type. unsigned Index = Idx.getIndex() - FirstTypeID; if (TypeOffsets.size() == Index) TypeOffsets.push_back(Offset); else if (TypeOffsets.size() < Index) { TypeOffsets.resize(Index + 1); TypeOffsets[Index] = Offset; d2738 8 a2745 1 llvm_unreachable("Types emitted in wrong order"); d2747 6 d2787 1 a2787 1 auto Abbrev = std::make_shared(); d2792 1 a2792 1 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2800 1 a2800 1 Abbrev = std::make_shared(); d2805 1 a2805 1 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2830 1 a2830 1 auto Abbrev = std::make_shared(); d2834 1 a2834 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); a2859 1 a2963 1 d3036 1 a3036 1 auto Abbrev = std::make_shared(); d3041 1 a3041 1 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d3051 1 a3051 1 Abbrev = std::make_shared(); d3056 1 a3056 1 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); a3075 1 ASTRecordWriter Writer(*this, Record); d3083 2 a3084 2 Writer.AddSelectorRef(Sel); Writer.AddSourceLocation(Loc); d3086 1 a3086 1 Writer.Emit(REFERENCED_SELECTOR_POOL); d3106 1 a3106 8 // If we find a local decl, we're done. if (!Redecl->isFromASTFile()) { // Exception: in very rare cases (for injected-class-names), not all // redeclarations are in the same semantic context. Skip ones in a // different context. They don't go in this lookup table at all. if (!Redecl->getDeclContext()->getRedeclContext()->Equals( D->getDeclContext()->getRedeclContext())) continue; a3107 2 } d3110 1 a3110 1 if (Redecl->getOwningModuleID() == 0) a3124 1 a3164 2 bool needDecls() const { return NeedDecls; } a3172 1 a3265 1 d3310 1 a3310 6 // Write out identifiers if either the ID is local or the identifier has // changed since it was loaded. if (ID >= FirstIdentID || !Chain || !II->isFromAST() || II->hasChangedSinceDeserialization() || (Trait.needDecls() && II->hasFETokenInfoChangedSinceDeserialization())) d3326 1 a3326 1 auto Abbrev = std::make_shared(); d3330 1 a3330 1 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d3338 1 a3338 1 auto Abbrev = std::make_shared(); d3343 1 a3343 1 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); a3366 1 a3491 1 d3813 2 a3814 8 for (const auto &I:Opts.OptMap) { AddString(I.getKey(), Record); auto V = I.getValue(); Record.push_back(V.Supported ? 1 : 0); Record.push_back(V.Enabled ? 1 : 0); Record.push_back(V.Avail); Record.push_back(V.Core); } a3817 36 void ASTWriter::WriteOpenCLExtensionTypes(Sema &SemaRef) { if (!SemaRef.Context.getLangOpts().OpenCL) return; RecordData Record; for (const auto &I : SemaRef.OpenCLTypeExtMap) { Record.push_back( static_cast(getTypeID(I.first->getCanonicalTypeInternal()))); Record.push_back(I.second.size()); for (auto Ext : I.second) AddString(Ext, Record); } Stream.EmitRecord(OPENCL_EXTENSION_TYPES, Record); } void ASTWriter::WriteOpenCLExtensionDecls(Sema &SemaRef) { if (!SemaRef.Context.getLangOpts().OpenCL) return; RecordData Record; for (const auto &I : SemaRef.OpenCLDeclExtMap) { Record.push_back(getDeclID(I.first)); Record.push_back(static_cast(I.second.size())); for (auto Ext : I.second) AddString(Ext, Record); } Stream.EmitRecord(OPENCL_EXTENSION_DECLS, Record); } void ASTWriter::WriteCUDAPragmas(Sema &SemaRef) { if (SemaRef.ForceCUDAHostDeviceDepth > 0) { RecordData::value_type Record[] = {SemaRef.ForceCUDAHostDeviceDepth}; Stream.EmitRecord(CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH, Record); } } d3855 1 a3855 1 auto Abbrev = std::make_shared(); d3859 1 a3859 1 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev)); d3877 1 a3877 1 for (auto &LPTMapEntry : LPTMap) { d3879 1 a3879 1 LateParsedTemplate &LPT = *LPTMapEntry.second; d3881 2 a3882 2 AddDeclRef(LPT.D, Record); Record.push_back(LPT.Toks.size()); d3884 1 a3884 1 for (const auto &Tok : LPT.Toks) { a3898 16 /// \brief Write the state of 'pragma ms_struct' at the end of the module. void ASTWriter::WriteMSStructPragmaOptions(Sema &SemaRef) { RecordData Record; Record.push_back(SemaRef.MSStructPragmaOn ? PMSST_ON : PMSST_OFF); Stream.EmitRecord(MSSTRUCT_PRAGMA_OPTIONS, Record); } /// \brief Write the state of 'pragma pointers_to_members' at the end of the //module. void ASTWriter::WriteMSPointersToMembersPragmaOptions(Sema &SemaRef) { RecordData Record; Record.push_back(SemaRef.MSPointerToMemberRepresentationMethod); AddSourceLocation(SemaRef.ImplicitMSInheritanceAttrLoc, Record); Stream.EmitRecord(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS, Record); } d3905 1 a3905 1 auto Abv = std::make_shared(); d3912 1 a3912 1 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv)); d3938 3 a3940 3 /// \brief Emit the list of attributes to the specified record. void ASTRecordWriter::AddAttributes(ArrayRef Attrs) { auto &Record = *this; d3944 1 a3944 1 Record.AddSourceRange(A->getRange()); d4035 24 a4058 4 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream, ArrayRef> Extensions, bool IncludeTimestamps) : Stream(Stream), IncludeTimestamps(IncludeTimestamps) { a4154 6 RegisterPredefDecl(Context.CFConstantStringTypeDecl, PREDEF_DECL_CF_CONSTANT_STRING_ID); RegisterPredefDecl(Context.CFConstantStringTagDecl, PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID); RegisterPredefDecl(Context.TypePackElementDecl, PREDEF_DECL_TYPE_PACK_ELEMENT_ID); d4217 1 a4217 1 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc || SemaRef.StdAlignValT) { a4219 1 AddDeclRef(SemaRef.getStdAlignValT(), SemaDeclRefs); d4282 1 a4282 1 auto Abv = std::make_shared(); d4285 1 a4285 1 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv)); d4293 1 a4293 1 Abv = std::make_shared(); d4297 1 a4297 1 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv)); d4326 2 a4327 3 // an AST file, are registered for serialization. Likewise for template // specializations added to imported templates. for (const auto *I : DeclsToEmitEvenIfUnreferenced) { a4350 13 // For method pool in the module, if it contains an entry for a selector, // the entry should be complete, containing everything introduced by that // module and all modules it imports. It's possible that the entry is out of // date, so we need to pull in the new content here. // It's possible that updateOutOfDateSelector can update SelectorIDs. To be // safe, we copy all selectors out. llvm::SmallVector AllSelectors; for (auto &SelectorAndID : SelectorIDs) AllSelectors.push_back(SelectorAndID.first); for (auto &Selector : AllSelectors) SemaRef.updateOutOfDateSelector(Selector); d4378 1 a4378 1 auto Abbrev = std::make_shared(); d4381 1 a4381 1 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d4448 2 a4460 3 WriteOpenCLExtensionTypes(SemaRef); WriteOpenCLExtensionDecls(SemaRef); WriteCUDAPragmas(SemaRef); d4570 1 d4572 1 a4572 1 if(!WritingModule) { a4573 3 WriteMSStructPragmaOptions(SemaRef); WriteMSPointersToMembersPragmaOptions(SemaRef); } d4599 1 a4599 2 RecordData RecordData; ASTRecordWriter Record(*this, RecordData); d4603 1 a4603 7 // An updated body is emitted last, so that the reader doesn't need // to skip over the lazy body to reach statements for other records. if (Kind == UPD_CXX_ADDED_FUNCTION_DEFINITION) HasUpdatedBody = true; else Record.push_back(Kind); d4613 4 d4620 1 a4620 1 Record.AddSourceLocation(Update.getLoc()); d4624 2 a4625 7 Record.AddStmt(const_cast( cast(Update.getDecl())->getDefaultArg())); break; case UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER: Record.AddStmt( cast(Update.getDecl())->getInClassInitializer()); d4631 2 a4632 2 Record.AddCXXDefinitionData(RD); Record.AddOffset(WriteDeclContextLexicalBlock( d4640 1 a4640 1 Record.AddSourceLocation(MSInfo->getPointOfInstantiation()); d4644 1 a4644 1 Record.AddSourceLocation(Spec->getPointOfInstantiation()); d4652 3 a4654 3 Record.AddDeclRef(PartialSpec); Record.AddTemplateArgumentList( &Spec->getTemplateInstantiationArgs()); d4660 3 a4662 3 Record.AddSourceLocation(RD->getLocation()); Record.AddSourceLocation(RD->getLocStart()); Record.AddSourceRange(RD->getBraceRange()); d4666 3 a4668 2 if (D->hasAttrs()) Record.AddAttributes(D->getAttrs()); d4675 1 a4675 1 Record.AddDeclRef(Update.getDecl()); d4680 1 d4698 2 a4699 7 Record.AddSourceRange( D->getAttr()->getRange()); break; case UPD_DECL_MARKED_OPENMP_DECLARETARGET: Record.AddSourceRange( D->getAttr()->getRange()); d4707 1 a4707 1 Record.AddAttributes(llvm::makeArrayRef(Update.getAttr())); d4716 2 a4717 2 Record.AddSourceLocation(Def->getInnerLocStart()); Record.AddFunctionDefinition(Def); d4721 17 a4737 1 OffsetsRecord.push_back(Record.Emit(DECL_UPDATES)); d4739 1 d4743 1 a4743 2 uint32_t Raw = Loc.getRawEncoding(); Record.push_back((Raw << 1) | (Raw >> 31)); d4751 2 a4752 2 void ASTRecordWriter::AddAPInt(const llvm::APInt &Value) { Record->push_back(Value.getBitWidth()); d4754 1 a4754 1 Record->append(Words, Words + Value.getNumWords()); d4757 3 a4759 3 void ASTRecordWriter::AddAPSInt(const llvm::APSInt &Value) { Record->push_back(Value.isUnsigned()); AddAPInt(Value); d4762 2 a4763 2 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) { AddAPInt(Value.bitcastToAPInt()); d4808 2 a4809 2 void ASTRecordWriter::AddSelectorRef(const Selector SelRef) { Record->push_back(Writer->getSelectorRef(SelRef)); d4831 2 a4832 2 void ASTRecordWriter::AddCXXTemporary(const CXXTemporary *Temp) { AddDeclRef(Temp->getDestructor()); d4835 21 a4855 2 void ASTRecordWriter::AddTemplateArgumentLocInfo( TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg) { d4861 1 a4861 1 AddTypeSourceInfo(Arg.getAsTypeSourceInfo()); d4864 2 a4865 2 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); AddSourceLocation(Arg.getTemplateNameLoc()); d4868 3 a4870 3 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); AddSourceLocation(Arg.getTemplateNameLoc()); AddSourceLocation(Arg.getTemplateEllipsisLoc()); d4882 3 a4884 2 void ASTRecordWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) { AddTemplateArgument(Arg.getArgument()); d4889 1 a4889 1 Record->push_back(InfoHasSameExpr); d4893 2 a4894 1 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo()); d4897 2 a4898 1 void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo) { d4900 1 a4900 1 AddTypeRef(QualType()); d4904 1 a4904 1 AddTypeLoc(TInfo->getTypeLoc()); d4907 2 a4908 2 void ASTRecordWriter::AddTypeLoc(TypeLoc TL) { AddTypeRef(TL.getType()); d4910 1 a4910 1 TypeLocWriter TLW(*this); d5045 1 a5045 1 void ASTRecordWriter::AddDeclarationName(DeclarationName Name) { d5047 1 a5047 1 Record->push_back(Name.getNameKind()); d5050 1 a5050 1 AddIdentifierRef(Name.getAsIdentifierInfo()); d5056 1 a5056 1 AddSelectorRef(Name.getObjCSelector()); d5062 1 a5062 1 AddTypeRef(Name.getCXXNameType()); d5066 1 a5066 1 Record->push_back(Name.getCXXOverloadedOperator()); d5070 1 a5070 1 AddIdentifierRef(Name.getCXXLiteralIdentifier()); d5100 2 a5101 2 void ASTRecordWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name) { d5106 1 a5106 1 AddTypeSourceInfo(DNLoc.NamedType.TInfo); a5109 2 AddSourceLocation(SourceLocation::getFromRawEncoding( DNLoc.CXXOperatorName.BeginOpNameLoc)); d5111 5 a5115 1 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc)); d5119 3 a5121 2 AddSourceLocation(SourceLocation::getFromRawEncoding( DNLoc.CXXLiteralOperatorName.OpNameLoc)); d5133 13 a5145 5 void ASTRecordWriter::AddDeclarationNameInfo( const DeclarationNameInfo &NameInfo) { AddDeclarationName(NameInfo.getName()); AddSourceLocation(NameInfo.getLoc()); AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName()); d5148 2 a5149 8 void ASTRecordWriter::AddQualifierInfo(const QualifierInfo &Info) { AddNestedNameSpecifierLoc(Info.QualifierLoc); Record->push_back(Info.NumTemplParamLists); for (unsigned i = 0, e = Info.NumTemplParamLists; i != e; ++i) AddTemplateParameterList(Info.TemplParamLists[i]); } void ASTRecordWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS) { d5160 1 a5160 1 Record->push_back(NestedNames.size()); d5164 1 a5164 1 Record->push_back(Kind); d5167 1 a5167 1 AddIdentifierRef(NNS->getAsIdentifier()); d5171 1 a5171 1 AddDeclRef(NNS->getAsNamespace()); d5175 1 a5175 1 AddDeclRef(NNS->getAsNamespaceAlias()); d5180 2 a5181 2 AddTypeRef(QualType(NNS->getAsType(), 0)); Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); d5189 1 a5189 1 AddDeclRef(NNS->getAsRecordDecl()); d5195 2 a5196 1 void ASTRecordWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) { d5208 1 a5208 1 Record->push_back(NestedNames.size()); d5213 1 a5213 1 Record->push_back(Kind); d5216 2 a5217 2 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier()); AddSourceRange(NNS.getLocalSourceRange()); d5221 2 a5222 2 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace()); AddSourceRange(NNS.getLocalSourceRange()); d5226 2 a5227 2 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias()); AddSourceRange(NNS.getLocalSourceRange()); d5232 3 a5234 3 Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); AddTypeLoc(NNS.getTypeLoc()); AddSourceLocation(NNS.getLocalSourceRange().getEnd()); d5238 1 a5238 1 AddSourceLocation(NNS.getLocalSourceRange().getEnd()); d5242 2 a5243 2 AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl()); AddSourceRange(NNS.getLocalSourceRange()); d5249 1 a5249 1 void ASTRecordWriter::AddTemplateName(TemplateName Name) { d5251 1 a5251 1 Record->push_back(Kind); d5254 1 a5254 1 AddDeclRef(Name.getAsTemplateDecl()); d5259 1 a5259 1 Record->push_back(OvT->size()); d5261 1 a5261 1 AddDeclRef(I); d5267 3 a5269 3 AddNestedNameSpecifier(QualT->getQualifier()); Record->push_back(QualT->hasTemplateKeyword()); AddDeclRef(QualT->getTemplateDecl()); d5275 2 a5276 2 AddNestedNameSpecifier(DepT->getQualifier()); Record->push_back(DepT->isIdentifier()); d5278 1 a5278 1 AddIdentifierRef(DepT->getIdentifier()); d5280 1 a5280 1 Record->push_back(DepT->getOperator()); d5287 2 a5288 2 AddDeclRef(subst->getParameter()); AddTemplateName(subst->getReplacement()); d5295 2 a5296 2 AddDeclRef(SubstPack->getParameterPack()); AddTemplateArgument(SubstPack->getArgumentPack()); d5302 3 a5304 2 void ASTRecordWriter::AddTemplateArgument(const TemplateArgument &Arg) { Record->push_back(Arg.getKind()); d5309 1 a5309 1 AddTypeRef(Arg.getAsType()); d5312 2 a5313 2 AddDeclRef(Arg.getAsDecl()); AddTypeRef(Arg.getParamTypeForDecl()); d5316 1 a5316 1 AddTypeRef(Arg.getNullPtrType()); d5319 2 a5320 2 AddAPSInt(Arg.getAsIntegral()); AddTypeRef(Arg.getIntegralType()); d5323 1 a5323 1 AddTemplateName(Arg.getAsTemplateOrTemplatePattern()); d5326 1 a5326 1 AddTemplateName(Arg.getAsTemplateOrTemplatePattern()); d5328 1 a5328 1 Record->push_back(*NumExpansions + 1); d5330 1 a5330 1 Record->push_back(0); d5336 1 a5336 1 Record->push_back(Arg.pack_size()); d5338 1 a5338 1 AddTemplateArgument(P); d5343 3 a5345 2 void ASTRecordWriter::AddTemplateParameterList( const TemplateParameterList *TemplateParams) { d5347 4 a5350 5 AddSourceLocation(TemplateParams->getTemplateLoc()); AddSourceLocation(TemplateParams->getLAngleLoc()); AddSourceLocation(TemplateParams->getRAngleLoc()); // TODO: Concepts Record->push_back(TemplateParams->size()); d5352 1 a5352 1 AddDeclRef(P); d5356 3 a5358 2 void ASTRecordWriter::AddTemplateArgumentList( const TemplateArgumentList *TemplateArgs) { d5360 3 a5362 3 Record->push_back(TemplateArgs->size()); for (int i = 0, e = TemplateArgs->size(); i != e; ++i) AddTemplateArgument(TemplateArgs->get(i)); d5365 3 a5367 2 void ASTRecordWriter::AddASTTemplateArgumentListInfo( const ASTTemplateArgumentListInfo *ASTTemplArgList) { d5369 3 a5371 3 AddSourceLocation(ASTTemplArgList->LAngleLoc); AddSourceLocation(ASTTemplArgList->RAngleLoc); Record->push_back(ASTTemplArgList->NumTemplateArgs); d5373 2 a5374 2 for (int i = 0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) AddTemplateArgumentLoc(TemplArgs[i]); d5377 3 a5379 2 void ASTRecordWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set) { Record->push_back(Set.size()); d5382 2 a5383 2 AddDeclRef(I.getDecl()); Record->push_back(I.getAccess()); d5387 8 a5394 8 // FIXME: Move this out of the main ASTRecordWriter interface. void ASTRecordWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base) { Record->push_back(Base.isVirtual()); Record->push_back(Base.isBaseOfClass()); Record->push_back(Base.getAccessSpecifierAsWritten()); Record->push_back(Base.getInheritConstructors()); AddTypeSourceInfo(Base.getTypeSourceInfo()); AddSourceRange(Base.getSourceRange()); d5396 2 a5397 1 : SourceLocation()); d5400 15 a5414 5 static uint64_t EmitCXXBaseSpecifiers(ASTWriter &W, ArrayRef Bases) { ASTWriter::RecordData Record; ASTRecordWriter Writer(W, Record); Writer.push_back(Bases.size()); d5416 10 a5425 2 for (auto &Base : Bases) Writer.AddCXXBaseSpecifier(Base); d5427 12 a5438 2 return Writer.Emit(serialization::DECL_CXX_BASE_SPECIFIERS); } a5439 13 // FIXME: Move this out of the main ASTRecordWriter interface. void ASTRecordWriter::AddCXXBaseSpecifiers(ArrayRef Bases) { AddOffset(EmitCXXBaseSpecifiers(*Writer, Bases)); } static uint64_t EmitCXXCtorInitializers(ASTWriter &W, ArrayRef CtorInits) { ASTWriter::RecordData Record; ASTRecordWriter Writer(W, Record); Writer.push_back(CtorInits.size()); for (auto *Init : CtorInits) { d5441 3 a5443 3 Writer.push_back(CTOR_INITIALIZER_BASE); Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); Writer.push_back(Init->isBaseVirtual()); d5445 2 a5446 2 Writer.push_back(CTOR_INITIALIZER_DELEGATING); Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); d5448 2 a5449 2 Writer.push_back(CTOR_INITIALIZER_MEMBER); Writer.AddDeclRef(Init->getMember()); d5451 2 a5452 2 Writer.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); Writer.AddDeclRef(Init->getIndirectMember()); d5455 12 a5466 7 Writer.AddSourceLocation(Init->getMemberLocation()); Writer.AddStmt(Init->getInit()); Writer.AddSourceLocation(Init->getLParenLoc()); Writer.AddSourceLocation(Init->getRParenLoc()); Writer.push_back(Init->isWritten()); if (Init->isWritten()) Writer.push_back(Init->getSourceOrder()); d5468 19 d5488 6 a5493 2 return Writer.Emit(serialization::DECL_CXX_CTOR_INITIALIZERS); } d5495 3 a5497 4 // FIXME: Move this out of the main ASTRecordWriter interface. void ASTRecordWriter::AddCXXCtorInitializers( ArrayRef CtorInits) { AddOffset(EmitCXXCtorInitializers(*Writer, CtorInits)); d5500 1 a5500 1 void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { d5502 38 a5539 42 Record->push_back(Data.IsLambda); Record->push_back(Data.UserDeclaredConstructor); Record->push_back(Data.UserDeclaredSpecialMembers); Record->push_back(Data.Aggregate); Record->push_back(Data.PlainOldData); Record->push_back(Data.Empty); Record->push_back(Data.Polymorphic); Record->push_back(Data.Abstract); Record->push_back(Data.IsStandardLayout); Record->push_back(Data.HasNoNonEmptyBases); Record->push_back(Data.HasPrivateFields); Record->push_back(Data.HasProtectedFields); Record->push_back(Data.HasPublicFields); Record->push_back(Data.HasMutableFields); Record->push_back(Data.HasVariantMembers); Record->push_back(Data.HasOnlyCMembers); Record->push_back(Data.HasInClassInitializer); Record->push_back(Data.HasUninitializedReferenceMember); Record->push_back(Data.HasUninitializedFields); Record->push_back(Data.HasInheritedConstructor); Record->push_back(Data.HasInheritedAssignment); Record->push_back(Data.NeedOverloadResolutionForMoveConstructor); Record->push_back(Data.NeedOverloadResolutionForMoveAssignment); Record->push_back(Data.NeedOverloadResolutionForDestructor); Record->push_back(Data.DefaultedMoveConstructorIsDeleted); Record->push_back(Data.DefaultedMoveAssignmentIsDeleted); Record->push_back(Data.DefaultedDestructorIsDeleted); Record->push_back(Data.HasTrivialSpecialMembers); Record->push_back(Data.DeclaredNonTrivialSpecialMembers); Record->push_back(Data.HasIrrelevantDestructor); Record->push_back(Data.HasConstexprNonCopyMoveConstructor); Record->push_back(Data.HasDefaultedDefaultConstructor); Record->push_back(Data.DefaultedDefaultConstructorIsConstexpr); Record->push_back(Data.HasConstexprDefaultConstructor); Record->push_back(Data.HasNonLiteralTypeFieldsOrBases); Record->push_back(Data.ComputedVisibleConversions); Record->push_back(Data.UserProvidedDefaultConstructor); Record->push_back(Data.DeclaredSpecialMembers); Record->push_back(Data.ImplicitCopyConstructorHasConstParam); Record->push_back(Data.ImplicitCopyAssignmentHasConstParam); Record->push_back(Data.HasDeclaredCopyConstructorWithConstParam); Record->push_back(Data.HasDeclaredCopyAssignmentWithConstParam); d5542 1 a5542 1 Record->push_back(Data.NumBases); d5544 3 a5546 2 AddCXXBaseSpecifiers(Data.bases()); d5548 1 a5548 1 Record->push_back(Data.NumVBases); d5550 2 a5551 1 AddCXXBaseSpecifiers(Data.vbases()); d5553 2 a5554 2 AddUnresolvedSet(Data.Conversions.get(*Writer->Context)); AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context)); d5556 1 a5556 1 AddDeclRef(D->getFirstFriend()); d5561 8 a5568 8 Record->push_back(Lambda.Dependent); Record->push_back(Lambda.IsGenericLambda); Record->push_back(Lambda.CaptureDefault); Record->push_back(Lambda.NumCaptures); Record->push_back(Lambda.NumExplicitCaptures); Record->push_back(Lambda.ManglingNumber); AddDeclRef(D->getLambdaContextDecl()); AddTypeSourceInfo(Lambda.MethodTyInfo); d5571 3 a5573 3 AddSourceLocation(Capture.getLocation()); Record->push_back(Capture.isImplicit()); Record->push_back(Capture.getCaptureKind()); a5574 1 case LCK_StarThis: d5582 1 a5582 1 AddDeclRef(Var); d5584 2 a5585 1 : SourceLocation()); a5664 1 if (Chain && Chain->isProcessingUpdateRecords()) return; d5685 4 d5695 2 a5696 14 if (Chain && Chain->isProcessingUpdateRecords()) return; assert(DC->isLookupContext() && "Should not add lookup results to non-lookup contexts!"); // TU is handled elsewhere. if (isa(DC)) return; // Namespaces are handled elsewhere, except for template instantiations of // FunctionTemplateDecls in namespaces. We are interested in cases where the // local instantiations are added to an imported context. Only happens when // adding ADL lookup candidates, for example templated friends. if (isa(DC) && D->getFriendObjectKind() == Decl::FOK_None && !isa(D)) d5712 1 a5712 1 DeclsToEmitEvenIfUnreferenced.push_back(Child); d5714 1 a5714 1 DeclsToEmitEvenIfUnreferenced.push_back(D); a5717 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5734 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5748 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5758 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5767 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5776 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5784 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5796 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5804 9 void ASTWriter::DefaultMemberInitializerInstantiated(const FieldDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER, D)); } a5806 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5816 1 if (Chain && Chain->isProcessingUpdateRecords()) return; d5818 2 a5819 7 // If there is *any* declaration of the entity that's not from an AST file, // we can skip writing the update record. We make sure that isUsed() triggers // completion of the redeclaration chain of the entity. for (auto Prev = D->getMostRecentDecl(); Prev; Prev = Prev->getPreviousDecl()) if (IsLocalDecl(Prev)) return; a5824 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5831 11 void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(const Decl *D, const Attr *Attr) { if (Chain && Chain->isProcessingUpdateRecords()) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back( DeclUpdate(UPD_DECL_MARKED_OPENMP_DECLARETARGET, Attr)); } a5832 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5839 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5844 36 void ASTWriter::AddedCXXTemplateSpecialization( const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!TD->getFirstDecl()->isFromASTFile()) return; if (Chain && Chain->isProcessingUpdateRecords()) return; DeclsToEmitEvenIfUnreferenced.push_back(D); } void ASTWriter::AddedCXXTemplateSpecialization( const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!TD->getFirstDecl()->isFromASTFile()) return; if (Chain && Chain->isProcessingUpdateRecords()) return; DeclsToEmitEvenIfUnreferenced.push_back(D); } void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!TD->getFirstDecl()->isFromASTFile()) return; if (Chain && Chain->isProcessingUpdateRecords()) return; DeclsToEmitEvenIfUnreferenced.push_back(D); } @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @d15 1 a19 1 #include "clang/AST/ASTUnresolvedSet.h" a21 1 #include "clang/AST/DeclCXX.h" d23 1 a26 4 #include "clang/AST/LambdaCapture.h" #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/RawCommentList.h" #include "clang/AST/TemplateName.h" d31 1 a31 5 #include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/Module.h" #include "clang/Basic/ObjCRuntime.h" a40 1 #include "clang/Lex/ModuleMap.h" a43 1 #include "clang/Lex/Token.h" a44 1 #include "clang/Sema/ObjCMethodList.h" a45 1 #include "clang/Sema/Weak.h" a46 2 #include "clang/Serialization/Module.h" #include "clang/Serialization/ModuleFileExtension.h" a50 5 #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/STLExtras.h" a51 1 #include "llvm/Bitcode/BitCodes.h" a52 2 #include "llvm/Support/Casting.h" #include "llvm/Support/Compression.h" d54 1 a54 1 #include "llvm/Support/ErrorHandling.h" a58 1 #include "llvm/Support/raw_ostream.h" d60 2 a61 8 #include #include #include #include #include #include #include #include d84 1 a84 2 namespace clang { d87 1 a87 1 ASTRecordWriter Record; d89 1 a94 1 public: d96 1 a96 24 : Writer(Writer), Record(Writer, Record), Code((TypeCode)0), AbbrevToUse(0) { } uint64_t Emit() { return Record.Emit(Code, AbbrevToUse); } void Visit(QualType T) { if (T.hasLocalNonFastQualifiers()) { Qualifiers Qs = T.getLocalQualifiers(); Record.AddTypeRef(T.getLocalUnqualifiedType()); Record.push_back(Qs.getAsOpaqueValue()); Code = TYPE_EXT_QUAL; AbbrevToUse = Writer.TypeExtQualAbbrev; } else { switch (T->getTypeClass()) { // For all of the concrete, non-dependent types, call the // appropriate visitor function. #define TYPE(Class, Base) \ case Type::Class: Visit##Class##Type(cast(T)); break; #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" } } } d106 1 a106 2 } // end namespace clang d113 1 a113 1 Record.AddTypeRef(T->getElementType()); d118 1 a118 1 Record.AddTypeRef(T->getPointeeType()); d123 1 a123 1 Record.AddTypeRef(T->getOriginalType()); d128 2 a129 2 Record.AddTypeRef(T->getOriginalType()); Record.AddTypeRef(T->getAdjustedType()); d134 1 a134 1 Record.AddTypeRef(T->getPointeeType()); d139 1 a139 1 Record.AddTypeRef(T->getPointeeTypeAsWritten()); d145 1 a145 1 Record.AddTypeRef(T->getPointeeTypeAsWritten()); d150 2 a151 2 Record.AddTypeRef(T->getPointeeType()); Record.AddTypeRef(QualType(T->getClass(), 0)); d156 1 a156 1 Record.AddTypeRef(T->getElementType()); d163 1 a163 1 Record.AddAPInt(T->getSize()); d174 3 a176 3 Record.AddSourceLocation(T->getLBracketLoc()); Record.AddSourceLocation(T->getRBracketLoc()); Record.AddStmt(T->getSizeExpr()); d181 1 a181 1 Record.AddTypeRef(T->getElementType()); d193 1 a193 1 Record.AddTypeRef(T->getReturnType()); d211 2 a212 2 static void addExceptionSpec(const FunctionProtoType *T, ASTRecordWriter &Record) { d217 1 a217 1 Record.AddTypeRef(T->getExceptionType(I)); d219 1 a219 1 Record.AddStmt(T->getNoexceptExpr()); d221 2 a222 2 Record.AddDeclRef(T->getExceptionSpecDecl()); Record.AddDeclRef(T->getExceptionSpecTemplate()); d224 1 a224 1 Record.AddDeclRef(T->getExceptionSpecDecl()); d235 1 a235 1 addExceptionSpec(T, Record); d239 1 a239 6 Record.AddTypeRef(T->getParamType(I)); if (T->hasExtParameterInfos()) { for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Record.push_back(T->getExtParameterInfo(I).getOpaqueValue()); } d242 1 a242 2 T->getRefQualifier() || T->getExceptionSpecType() != EST_None || T->hasExtParameterInfos()) d249 1 a249 1 Record.AddDeclRef(T->getDecl()); d254 1 a254 1 Record.AddDeclRef(T->getDecl()); d256 1 a256 1 Record.AddTypeRef(T->getCanonicalTypeInternal()); d261 1 a261 1 Record.AddStmt(T->getUnderlyingExpr()); d266 1 a266 1 Record.AddTypeRef(T->getUnderlyingType()); d271 2 a272 2 Record.AddTypeRef(T->getUnderlyingType()); Record.AddStmt(T->getUnderlyingExpr()); d277 2 a278 2 Record.AddTypeRef(T->getBaseType()); Record.AddTypeRef(T->getUnderlyingType()); d284 1 a284 1 Record.AddTypeRef(T->getDeducedType()); d293 1 a293 1 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); d309 2 a310 2 Record.AddTypeRef(T->getModifiedType()); Record.AddTypeRef(T->getEquivalentType()); d318 2 a319 2 Record.AddTypeRef(QualType(T->getReplacedParameter(), 0)); Record.AddTypeRef(T->getReplacementType()); d326 2 a327 2 Record.AddTypeRef(QualType(T->getReplacedParameter(), 0)); Record.AddTemplateArgument(T->getArgumentPack()); d335 1 a335 1 Record.AddTemplateName(T->getTemplateName()); d338 5 a342 5 Record.AddTemplateArgument(ArgI); Record.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() : T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal()); d349 2 a350 2 Record.AddStmt(T->getSizeExpr()); Record.AddSourceRange(T->getBracketsRange()); d366 1 a366 1 Record.AddDeclRef(T->getDecl()); d373 5 a377 4 Record.AddNestedNameSpecifier(T->getQualifier()); Record.AddIdentifierRef(T->getIdentifier()); Record.AddTypeRef( T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal()); d385 2 a386 2 Record.AddNestedNameSpecifier(T->getQualifier()); Record.AddIdentifierRef(T->getIdentifier()); d389 1 a389 1 Record.AddTemplateArgument(I); d394 1 a394 1 Record.AddTypeRef(T->getPattern()); d403 1 a403 1 Record.AddTypeRef(T->getInnerType()); d409 2 a410 2 Record.AddNestedNameSpecifier(T->getQualifier()); Record.AddTypeRef(T->getNamedType()); d415 2 a416 2 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); Record.AddTypeRef(T->getInjectedSpecializationType()); d421 1 a421 1 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); a424 8 void ASTTypeWriter::VisitObjCTypeParamType(const ObjCTypeParamType *T) { Record.AddDeclRef(T->getDecl()); Record.push_back(T->getNumProtocols()); for (const auto *I : T->quals()) Record.AddDeclRef(I); Code = TYPE_OBJC_TYPE_PARAM; } d426 1 a426 1 Record.AddTypeRef(T->getBaseType()); d429 1 a429 1 Record.AddTypeRef(TypeArg); d432 1 a432 1 Record.AddDeclRef(I); d439 1 a439 1 Record.AddTypeRef(T->getPointeeType()); d445 1 a445 1 Record.AddTypeRef(T->getValueType()); d451 1 a451 2 Record.AddTypeRef(T->getElementType()); Record.push_back(T->isReadOnly()); d458 2 a459 1 ASTRecordWriter &Record; d462 2 a463 2 TypeLocWriter(ASTRecordWriter &Record) : Record(Record) { } a478 1 d480 1 a480 1 Record.AddSourceLocation(TL.getBuiltinLoc()); a487 1 d489 1 a489 1 Record.AddSourceLocation(TL.getNameLoc()); a490 1 d492 1 a492 1 Record.AddSourceLocation(TL.getStarLoc()); a493 1 a496 1 a499 1 d501 1 a501 1 Record.AddSourceLocation(TL.getCaretLoc()); a502 1 d504 1 a504 1 Record.AddSourceLocation(TL.getAmpLoc()); a505 1 d507 1 a507 1 Record.AddSourceLocation(TL.getAmpAmpLoc()); a508 1 d510 2 a511 2 Record.AddSourceLocation(TL.getStarLoc()); Record.AddTypeSourceInfo(TL.getClassTInfo()); a512 1 d514 2 a515 2 Record.AddSourceLocation(TL.getLBracketLoc()); Record.AddSourceLocation(TL.getRBracketLoc()); d518 1 a518 1 Record.AddStmt(TL.getSizeExpr()); a519 1 a522 1 a525 1 a528 1 a532 1 d535 1 a535 1 Record.AddSourceLocation(TL.getNameLoc()); a536 1 d538 1 a538 1 Record.AddSourceLocation(TL.getNameLoc()); a539 1 d541 1 a541 1 Record.AddSourceLocation(TL.getNameLoc()); a542 1 d544 4 a547 4 Record.AddSourceLocation(TL.getLocalRangeBegin()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); Record.AddSourceLocation(TL.getLocalRangeEnd()); d549 1 a549 1 Record.AddDeclRef(TL.getParam(i)); d558 1 a558 1 Record.AddSourceLocation(TL.getNameLoc()); d561 1 a561 9 Record.AddSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { if (TL.getNumProtocols()) { Record.AddSourceLocation(TL.getProtocolLAngleLoc()); Record.AddSourceLocation(TL.getProtocolRAngleLoc()); } for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) Record.AddSourceLocation(TL.getProtocolLoc(i)); d564 3 a566 3 Record.AddSourceLocation(TL.getTypeofLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); a567 1 d569 4 a572 4 Record.AddSourceLocation(TL.getTypeofLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); a573 1 d575 1 a575 1 Record.AddSourceLocation(TL.getNameLoc()); a576 1 d578 4 a581 4 Record.AddSourceLocation(TL.getKWLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); a582 1 d584 1 a584 1 Record.AddSourceLocation(TL.getNameLoc()); a585 1 d587 1 a587 1 Record.AddSourceLocation(TL.getNameLoc()); a588 1 d590 1 a590 1 Record.AddSourceLocation(TL.getNameLoc()); a591 1 d593 1 a593 1 Record.AddSourceLocation(TL.getAttrNameLoc()); d596 2 a597 2 Record.AddSourceLocation(range.getBegin()); Record.AddSourceLocation(range.getEnd()); d602 1 a602 1 if (operand) Record.AddStmt(operand); d604 1 a604 1 Record.AddSourceLocation(TL.getAttrEnumOperandLoc()); a606 1 d608 1 a608 1 Record.AddSourceLocation(TL.getNameLoc()); a609 1 d612 1 a612 1 Record.AddSourceLocation(TL.getNameLoc()); a613 1 d616 1 a616 1 Record.AddSourceLocation(TL.getNameLoc()); a617 1 d620 4 a623 4 Record.AddSourceLocation(TL.getTemplateKeywordLoc()); Record.AddSourceLocation(TL.getTemplateNameLoc()); Record.AddSourceLocation(TL.getLAngleLoc()); Record.AddSourceLocation(TL.getRAngleLoc()); d625 2 a626 2 Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), TL.getArgLoc(i).getLocInfo()); a627 1 d629 2 a630 2 Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); a631 1 d633 2 a634 2 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); a635 1 d637 1 a637 1 Record.AddSourceLocation(TL.getNameLoc()); a638 1 d640 3 a642 3 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); Record.AddSourceLocation(TL.getNameLoc()); a643 1 d646 6 a651 6 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); Record.AddSourceLocation(TL.getTemplateKeywordLoc()); Record.AddSourceLocation(TL.getTemplateNameLoc()); Record.AddSourceLocation(TL.getLAngleLoc()); Record.AddSourceLocation(TL.getRAngleLoc()); d653 2 a654 2 Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), TL.getArgLoc(I).getLocInfo()); a655 1 d657 1 a657 1 Record.AddSourceLocation(TL.getEllipsisLoc()); a658 1 d660 1 a660 1 Record.AddSourceLocation(TL.getNameLoc()); a661 1 d664 2 a665 2 Record.AddSourceLocation(TL.getTypeArgsLAngleLoc()); Record.AddSourceLocation(TL.getTypeArgsRAngleLoc()); d667 3 a669 3 Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i)); Record.AddSourceLocation(TL.getProtocolLAngleLoc()); Record.AddSourceLocation(TL.getProtocolRAngleLoc()); d671 1 a671 1 Record.AddSourceLocation(TL.getProtocolLoc(i)); a672 1 d674 1 a674 1 Record.AddSourceLocation(TL.getStarLoc()); a675 1 d677 3 a679 3 Record.AddSourceLocation(TL.getKWLoc()); Record.AddSourceLocation(TL.getLParenLoc()); Record.AddSourceLocation(TL.getRParenLoc()); a680 1 d682 1 a682 1 Record.AddSourceLocation(TL.getKWLoc()); d688 1 a688 1 std::shared_ptr Abv; d691 1 a691 1 Abv = std::make_shared(); d695 1 a695 1 TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv)); d698 1 a698 1 Abv = std::make_shared(); d716 1 a716 1 TypeFunctionProtoAbbrev = Stream.EmitAbbrev(std::move(Abv)); d880 1 a880 1 Stream.EnterBlockInfoBlock(); d933 1 d937 1 a942 2 RECORD(OPENCL_EXTENSION_TYPES); RECORD(OPENCL_EXTENSION_DECLS); a955 2 RECORD(MSSTRUCT_PRAGMA_OPTIONS); RECORD(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS); d957 1 a958 1 RECORD(CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH); a964 1 RECORD(SM_SLOC_BUFFER_BLOB_COMPRESSED); a992 1 RECORD(SUBMODULE_INITIALIZERS); a1040 1 RECORD(TYPE_OBJC_TYPE_PARAM); a1078 1 RECORD(DECL_CXX_INHERITED_CONSTRUCTOR); a1093 1 RECORD(DECL_TYPE_ALIAS_TEMPLATE); a1095 1 RECORD(DECL_CXX_CTOR_INITIALIZERS); a1097 10 RECORD(DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK); RECORD(DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION); RECORD(DECL_IMPORT); RECORD(DECL_OMP_THREADPRIVATE); RECORD(DECL_EMPTY); RECORD(DECL_OBJC_TYPE_PARAM); RECORD(DECL_OMP_CAPTUREDEXPR); RECORD(DECL_PRAGMA_COMMENT); RECORD(DECL_PRAGMA_DETECT_MISMATCH); RECORD(DECL_OMP_DECLARE_REDUCTION); d1174 1 a1174 1 while (true) { d1193 1 a1193 1 auto MetadataAbbrev = std::make_shared(); d1203 1 a1203 1 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev)); d1226 1 a1226 1 auto Abbrev = std::make_shared(); d1229 1 a1229 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); d1246 1 a1246 1 auto Abbrev = std::make_shared(); d1249 1 a1249 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); d1456 1 a1456 1 auto FileAbbrev = std::make_shared(); d1460 1 a1460 1 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev)); d1474 1 a1474 1 auto Abbrev = std::make_shared(); d1477 1 a1477 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); a1495 1 a1502 1 d1512 1 a1512 1 auto IFAbbrev = std::make_shared(); d1520 1 a1520 1 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev)); d1580 1 a1580 1 auto OffsetsAbbrev = std::make_shared(); d1586 1 a1586 1 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev)); d1603 1 a1603 1 auto Abbrev = std::make_shared(); d1614 1 a1614 1 return Stream.EmitAbbrev(std::move(Abbrev)); d1622 1 a1622 1 auto Abbrev = std::make_shared(); d1629 1 a1629 1 return Stream.EmitAbbrev(std::move(Abbrev)); d1634 1 a1634 2 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream, bool Compressed) { d1637 2 a1638 5 auto Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED : SM_SLOC_BUFFER_BLOB)); if (Compressed) Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Uncompressed size d1640 1 a1640 1 return Stream.EmitAbbrev(std::move(Abbrev)); d1648 1 a1648 1 auto Abbrev = std::make_shared(); d1655 1 a1655 1 return Stream.EmitAbbrev(std::move(Abbrev)); a1658 1 d1674 1 a1674 1 StringRef Filename; d1695 1 a1695 1 unsigned KeyLen = key.Filename.size() + 1 + 8 + 8; d1712 1 a1712 1 Out.write(key.Filename.data(), KeyLen); a1766 1 d1800 1 a1800 1 StringRef Filename = File->getName(); d1805 2 a1806 2 Filename = StringRef(strdup(FilenameTmp.c_str())); SavedStrings.push_back(Filename.data()); d1828 1 a1828 1 auto Abbrev = std::make_shared(); d1834 1 a1834 1 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d1860 1 a1860 1 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 4); d1865 1 a1865 3 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false); unsigned SLocBufferBlobCompressedAbbrv = CreateSLocBufferBlobAbbrev(Stream, true); d1900 1 a1900 1 AddSourceLocation(File.getIncludeLoc(), Record); a1904 1 bool EmitBlob = false; d1926 8 a1933 2 if (Content->BufferOverridden || Content->IsTransient) EmitBlob = true; d1943 1 a1943 1 StringRef Name = Buffer->getBufferIdentifier(); d1945 5 a1949 2 StringRef(Name.data(), Name.size() + 1)); EmitBlob = true; d1951 1 a1951 1 if (Name == "") a1952 21 } if (EmitBlob) { // Include the implicit terminating null character in the on-disk buffer // if we're writing it uncompressed. const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1); // Compress the buffer if possible. We expect that almost all PCM // consumers will not want its contents. SmallString<0> CompressedBuffer; if (llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer) == llvm::zlib::StatusOK) { RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1}; Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, CompressedBuffer); } else { RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB}; Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob); d1958 4 a1961 6 AddSourceLocation(Expansion.getSpellingLoc(), Record); AddSourceLocation(Expansion.getExpansionLocStart(), Record); AddSourceLocation(Expansion.isMacroArgExpansion() ? SourceLocation() : Expansion.getExpansionLocEnd(), Record); d1981 1 a1981 1 auto Abbrev = std::make_shared(); d1986 1 a1986 1 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2128 21 a2148 21 // We write out exported module macros for PCH as well. auto Leafs = PP.getLeafModuleMacros(Name); SmallVector Worklist(Leafs.begin(), Leafs.end()); llvm::DenseMap Visits; while (!Worklist.empty()) { auto *Macro = Worklist.pop_back_val(); // Emit a record indicating this submodule exports this macro. ModuleMacroRecord.push_back( getSubmoduleID(Macro->getOwningModule())); ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name)); for (auto *M : Macro->overrides()) ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule())); Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); ModuleMacroRecord.clear(); // Enqueue overridden macros once we've visited all their ancestors. for (auto *M : Macro->overrides()) if (++Visits[M] == M->getNumOverridingMacros()) Worklist.push_back(M); d2150 2 a2151 1 EmittedModuleMacros = true; d2237 1 a2237 1 auto Abbrev = std::make_shared(); d2243 1 a2243 1 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2267 1 a2267 1 auto Abbrev = std::make_shared(); d2274 1 a2274 1 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2337 1 a2337 1 auto Abbrev = std::make_shared(); d2341 1 a2341 1 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2359 1 a2359 3 auto *Top = Mod->getTopLevelModule(); if (Top != WritingModule && !Top->fullModuleNameIs(StringRef(getLangOpts().CurrentModule))) d2393 1 a2393 1 auto Abbrev = std::make_shared(); d2406 1 a2406 1 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2408 1 a2408 1 Abbrev = std::make_shared(); d2411 1 a2411 1 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2413 1 a2413 1 Abbrev = std::make_shared(); d2416 1 a2416 1 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2418 1 a2418 1 Abbrev = std::make_shared(); d2421 1 a2421 1 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2423 1 a2423 1 Abbrev = std::make_shared(); d2426 1 a2426 1 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2428 1 a2428 1 Abbrev = std::make_shared(); d2432 1 a2432 1 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2434 1 a2434 1 Abbrev = std::make_shared(); d2437 1 a2437 1 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2439 1 a2439 1 Abbrev = std::make_shared(); d2442 1 a2442 1 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2444 1 a2444 1 Abbrev = std::make_shared(); d2447 1 a2447 1 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2449 1 a2449 1 Abbrev = std::make_shared(); d2452 1 a2452 1 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2454 1 a2454 1 Abbrev = std::make_shared(); d2458 1 a2458 1 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2460 1 a2460 1 Abbrev = std::make_shared(); d2463 1 a2463 1 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2465 1 a2465 1 Abbrev = std::make_shared(); d2469 1 a2469 1 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); a2590 7 // Emit the initializers, if any. RecordData Inits; for (Decl *D : Context->getModuleInitializers(Mod)) Inits.push_back(GetDeclRef(D)); if (!Inits.empty()) Stream.EmitRecord(SUBMODULE_INITIALIZERS, Inits); d2643 1 a2643 1 AddSourceLocation(point.Loc, Record); d2664 40 d2710 3 a2712 4 TypeIdx &IdxRef = TypeIdxs[T]; if (IdxRef.getIndex() == 0) // we haven't seen this type before. IdxRef = TypeIdx(NextTypeID++); TypeIdx Idx = IdxRef; d2716 9 d2729 1 a2729 2 W.Visit(T); uint64_t Offset = W.Emit(); d2731 6 a2736 7 // Record the offset for this type. unsigned Index = Idx.getIndex() - FirstTypeID; if (TypeOffsets.size() == Index) TypeOffsets.push_back(Offset); else if (TypeOffsets.size() < Index) { TypeOffsets.resize(Index + 1); TypeOffsets[Index] = Offset; d2738 8 a2745 1 llvm_unreachable("Types emitted in wrong order"); d2747 6 d2787 1 a2787 1 auto Abbrev = std::make_shared(); d2792 1 a2792 1 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2800 1 a2800 1 Abbrev = std::make_shared(); d2805 1 a2805 1 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2830 1 a2830 1 auto Abbrev = std::make_shared(); d2834 1 a2834 1 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); a2859 1 a2963 1 d3036 1 a3036 1 auto Abbrev = std::make_shared(); d3041 1 a3041 1 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d3051 1 a3051 1 Abbrev = std::make_shared(); d3056 1 a3056 1 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); a3075 1 ASTRecordWriter Writer(*this, Record); d3083 2 a3084 2 Writer.AddSelectorRef(Sel); Writer.AddSourceLocation(Loc); d3086 1 a3086 1 Writer.Emit(REFERENCED_SELECTOR_POOL); d3106 1 a3106 8 // If we find a local decl, we're done. if (!Redecl->isFromASTFile()) { // Exception: in very rare cases (for injected-class-names), not all // redeclarations are in the same semantic context. Skip ones in a // different context. They don't go in this lookup table at all. if (!Redecl->getDeclContext()->getRedeclContext()->Equals( D->getDeclContext()->getRedeclContext())) continue; a3107 2 } d3110 1 a3110 1 if (Redecl->getOwningModuleID() == 0) a3124 1 a3164 2 bool needDecls() const { return NeedDecls; } a3172 1 a3265 1 d3310 1 a3310 6 // Write out identifiers if either the ID is local or the identifier has // changed since it was loaded. if (ID >= FirstIdentID || !Chain || !II->isFromAST() || II->hasChangedSinceDeserialization() || (Trait.needDecls() && II->hasFETokenInfoChangedSinceDeserialization())) d3326 1 a3326 1 auto Abbrev = std::make_shared(); d3330 1 a3330 1 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d3338 1 a3338 1 auto Abbrev = std::make_shared(); d3343 1 a3343 1 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); a3366 1 a3491 1 d3813 2 a3814 8 for (const auto &I:Opts.OptMap) { AddString(I.getKey(), Record); auto V = I.getValue(); Record.push_back(V.Supported ? 1 : 0); Record.push_back(V.Enabled ? 1 : 0); Record.push_back(V.Avail); Record.push_back(V.Core); } a3817 36 void ASTWriter::WriteOpenCLExtensionTypes(Sema &SemaRef) { if (!SemaRef.Context.getLangOpts().OpenCL) return; RecordData Record; for (const auto &I : SemaRef.OpenCLTypeExtMap) { Record.push_back( static_cast(getTypeID(I.first->getCanonicalTypeInternal()))); Record.push_back(I.second.size()); for (auto Ext : I.second) AddString(Ext, Record); } Stream.EmitRecord(OPENCL_EXTENSION_TYPES, Record); } void ASTWriter::WriteOpenCLExtensionDecls(Sema &SemaRef) { if (!SemaRef.Context.getLangOpts().OpenCL) return; RecordData Record; for (const auto &I : SemaRef.OpenCLDeclExtMap) { Record.push_back(getDeclID(I.first)); Record.push_back(static_cast(I.second.size())); for (auto Ext : I.second) AddString(Ext, Record); } Stream.EmitRecord(OPENCL_EXTENSION_DECLS, Record); } void ASTWriter::WriteCUDAPragmas(Sema &SemaRef) { if (SemaRef.ForceCUDAHostDeviceDepth > 0) { RecordData::value_type Record[] = {SemaRef.ForceCUDAHostDeviceDepth}; Stream.EmitRecord(CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH, Record); } } d3855 1 a3855 1 auto Abbrev = std::make_shared(); d3859 1 a3859 1 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev)); d3877 1 a3877 1 for (auto &LPTMapEntry : LPTMap) { d3879 1 a3879 1 LateParsedTemplate &LPT = *LPTMapEntry.second; d3881 2 a3882 2 AddDeclRef(LPT.D, Record); Record.push_back(LPT.Toks.size()); d3884 1 a3884 1 for (const auto &Tok : LPT.Toks) { a3898 16 /// \brief Write the state of 'pragma ms_struct' at the end of the module. void ASTWriter::WriteMSStructPragmaOptions(Sema &SemaRef) { RecordData Record; Record.push_back(SemaRef.MSStructPragmaOn ? PMSST_ON : PMSST_OFF); Stream.EmitRecord(MSSTRUCT_PRAGMA_OPTIONS, Record); } /// \brief Write the state of 'pragma pointers_to_members' at the end of the //module. void ASTWriter::WriteMSPointersToMembersPragmaOptions(Sema &SemaRef) { RecordData Record; Record.push_back(SemaRef.MSPointerToMemberRepresentationMethod); AddSourceLocation(SemaRef.ImplicitMSInheritanceAttrLoc, Record); Stream.EmitRecord(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS, Record); } d3905 1 a3905 1 auto Abv = std::make_shared(); d3912 1 a3912 1 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv)); d3938 3 a3940 3 /// \brief Emit the list of attributes to the specified record. void ASTRecordWriter::AddAttributes(ArrayRef Attrs) { auto &Record = *this; d3944 1 a3944 1 Record.AddSourceRange(A->getRange()); d4035 24 a4058 4 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream, ArrayRef> Extensions, bool IncludeTimestamps) : Stream(Stream), IncludeTimestamps(IncludeTimestamps) { a4154 6 RegisterPredefDecl(Context.CFConstantStringTypeDecl, PREDEF_DECL_CF_CONSTANT_STRING_ID); RegisterPredefDecl(Context.CFConstantStringTagDecl, PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID); RegisterPredefDecl(Context.TypePackElementDecl, PREDEF_DECL_TYPE_PACK_ELEMENT_ID); d4217 1 a4217 1 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc || SemaRef.StdAlignValT) { a4219 1 AddDeclRef(SemaRef.getStdAlignValT(), SemaDeclRefs); d4282 1 a4282 1 auto Abv = std::make_shared(); d4285 1 a4285 1 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv)); d4293 1 a4293 1 Abv = std::make_shared(); d4297 1 a4297 1 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv)); d4326 2 a4327 3 // an AST file, are registered for serialization. Likewise for template // specializations added to imported templates. for (const auto *I : DeclsToEmitEvenIfUnreferenced) { a4350 13 // For method pool in the module, if it contains an entry for a selector, // the entry should be complete, containing everything introduced by that // module and all modules it imports. It's possible that the entry is out of // date, so we need to pull in the new content here. // It's possible that updateOutOfDateSelector can update SelectorIDs. To be // safe, we copy all selectors out. llvm::SmallVector AllSelectors; for (auto &SelectorAndID : SelectorIDs) AllSelectors.push_back(SelectorAndID.first); for (auto &Selector : AllSelectors) SemaRef.updateOutOfDateSelector(Selector); d4378 1 a4378 1 auto Abbrev = std::make_shared(); d4381 1 a4381 1 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d4448 2 a4460 3 WriteOpenCLExtensionTypes(SemaRef); WriteOpenCLExtensionDecls(SemaRef); WriteCUDAPragmas(SemaRef); a4465 11 else if (!getLangOpts().CurrentModule.empty()) { // If we're building a PCH in the implementation of a module, we may need // the description of the current module. // // FIXME: We may need other modules that we did not load from an AST file, // such as if a module declares a 'conflicts' on a different module. Module *M = PP.getHeaderSearchInfo().getModuleMap().findModule( getLangOpts().CurrentModule); if (M && !M->IsFromModuleFile) WriteSubmodules(M); } d4570 1 d4572 1 a4572 1 if(!WritingModule) { a4573 3 WriteMSStructPragmaOptions(SemaRef); WriteMSPointersToMembersPragmaOptions(SemaRef); } d4599 1 a4599 2 RecordData RecordData; ASTRecordWriter Record(*this, RecordData); d4603 1 a4603 7 // An updated body is emitted last, so that the reader doesn't need // to skip over the lazy body to reach statements for other records. if (Kind == UPD_CXX_ADDED_FUNCTION_DEFINITION) HasUpdatedBody = true; else Record.push_back(Kind); d4613 4 d4620 1 a4620 1 Record.AddSourceLocation(Update.getLoc()); d4624 2 a4625 7 Record.AddStmt(const_cast( cast(Update.getDecl())->getDefaultArg())); break; case UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER: Record.AddStmt( cast(Update.getDecl())->getInClassInitializer()); d4631 2 a4632 2 Record.AddCXXDefinitionData(RD); Record.AddOffset(WriteDeclContextLexicalBlock( d4640 1 a4640 1 Record.AddSourceLocation(MSInfo->getPointOfInstantiation()); d4644 1 a4644 1 Record.AddSourceLocation(Spec->getPointOfInstantiation()); d4652 3 a4654 3 Record.AddDeclRef(PartialSpec); Record.AddTemplateArgumentList( &Spec->getTemplateInstantiationArgs()); d4660 3 a4662 3 Record.AddSourceLocation(RD->getLocation()); Record.AddSourceLocation(RD->getLocStart()); Record.AddSourceRange(RD->getBraceRange()); d4666 3 a4668 2 if (D->hasAttrs()) Record.AddAttributes(D->getAttrs()); d4675 1 a4675 1 Record.AddDeclRef(Update.getDecl()); d4680 1 d4698 2 a4699 7 Record.AddSourceRange( D->getAttr()->getRange()); break; case UPD_DECL_MARKED_OPENMP_DECLARETARGET: Record.AddSourceRange( D->getAttr()->getRange()); d4707 1 a4707 1 Record.AddAttributes(llvm::makeArrayRef(Update.getAttr())); d4716 2 a4717 2 Record.AddSourceLocation(Def->getInnerLocStart()); Record.AddFunctionDefinition(Def); d4721 5 a4725 1 OffsetsRecord.push_back(Record.Emit(DECL_UPDATES)); d4729 13 d4743 1 a4743 2 uint32_t Raw = Loc.getRawEncoding(); Record.push_back((Raw << 1) | (Raw >> 31)); d4751 2 a4752 2 void ASTRecordWriter::AddAPInt(const llvm::APInt &Value) { Record->push_back(Value.getBitWidth()); d4754 1 a4754 1 Record->append(Words, Words + Value.getNumWords()); d4757 3 a4759 3 void ASTRecordWriter::AddAPSInt(const llvm::APSInt &Value) { Record->push_back(Value.isUnsigned()); AddAPInt(Value); d4762 2 a4763 2 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) { AddAPInt(Value.bitcastToAPInt()); d4808 2 a4809 2 void ASTRecordWriter::AddSelectorRef(const Selector SelRef) { Record->push_back(Writer->getSelectorRef(SelRef)); d4831 2 a4832 2 void ASTRecordWriter::AddCXXTemporary(const CXXTemporary *Temp) { AddDeclRef(Temp->getDestructor()); d4835 21 a4855 2 void ASTRecordWriter::AddTemplateArgumentLocInfo( TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg) { d4861 1 a4861 1 AddTypeSourceInfo(Arg.getAsTypeSourceInfo()); d4864 2 a4865 2 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); AddSourceLocation(Arg.getTemplateNameLoc()); d4868 3 a4870 3 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); AddSourceLocation(Arg.getTemplateNameLoc()); AddSourceLocation(Arg.getTemplateEllipsisLoc()); d4882 3 a4884 2 void ASTRecordWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) { AddTemplateArgument(Arg.getArgument()); d4889 1 a4889 1 Record->push_back(InfoHasSameExpr); d4893 2 a4894 1 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo()); d4897 2 a4898 1 void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo) { d4900 1 a4900 1 AddTypeRef(QualType()); d4904 1 a4904 1 AddTypeLoc(TInfo->getTypeLoc()); d4907 2 a4908 2 void ASTRecordWriter::AddTypeLoc(TypeLoc TL) { AddTypeRef(TL.getType()); d4910 1 a4910 1 TypeLocWriter TLW(*this); d5045 1 a5045 1 void ASTRecordWriter::AddDeclarationName(DeclarationName Name) { d5047 1 a5047 1 Record->push_back(Name.getNameKind()); d5050 1 a5050 1 AddIdentifierRef(Name.getAsIdentifierInfo()); d5056 1 a5056 1 AddSelectorRef(Name.getObjCSelector()); d5062 1 a5062 1 AddTypeRef(Name.getCXXNameType()); d5066 1 a5066 1 Record->push_back(Name.getCXXOverloadedOperator()); d5070 1 a5070 1 AddIdentifierRef(Name.getCXXLiteralIdentifier()); d5100 2 a5101 2 void ASTRecordWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name) { d5106 1 a5106 1 AddTypeSourceInfo(DNLoc.NamedType.TInfo); a5109 2 AddSourceLocation(SourceLocation::getFromRawEncoding( DNLoc.CXXOperatorName.BeginOpNameLoc)); d5111 5 a5115 1 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc)); d5119 3 a5121 2 AddSourceLocation(SourceLocation::getFromRawEncoding( DNLoc.CXXLiteralOperatorName.OpNameLoc)); d5133 13 a5145 5 void ASTRecordWriter::AddDeclarationNameInfo( const DeclarationNameInfo &NameInfo) { AddDeclarationName(NameInfo.getName()); AddSourceLocation(NameInfo.getLoc()); AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName()); d5148 2 a5149 8 void ASTRecordWriter::AddQualifierInfo(const QualifierInfo &Info) { AddNestedNameSpecifierLoc(Info.QualifierLoc); Record->push_back(Info.NumTemplParamLists); for (unsigned i = 0, e = Info.NumTemplParamLists; i != e; ++i) AddTemplateParameterList(Info.TemplParamLists[i]); } void ASTRecordWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS) { d5160 1 a5160 1 Record->push_back(NestedNames.size()); d5164 1 a5164 1 Record->push_back(Kind); d5167 1 a5167 1 AddIdentifierRef(NNS->getAsIdentifier()); d5171 1 a5171 1 AddDeclRef(NNS->getAsNamespace()); d5175 1 a5175 1 AddDeclRef(NNS->getAsNamespaceAlias()); d5180 2 a5181 2 AddTypeRef(QualType(NNS->getAsType(), 0)); Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); d5189 1 a5189 1 AddDeclRef(NNS->getAsRecordDecl()); d5195 2 a5196 1 void ASTRecordWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) { d5208 1 a5208 1 Record->push_back(NestedNames.size()); d5213 1 a5213 1 Record->push_back(Kind); d5216 2 a5217 2 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier()); AddSourceRange(NNS.getLocalSourceRange()); d5221 2 a5222 2 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace()); AddSourceRange(NNS.getLocalSourceRange()); d5226 2 a5227 2 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias()); AddSourceRange(NNS.getLocalSourceRange()); d5232 3 a5234 3 Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); AddTypeLoc(NNS.getTypeLoc()); AddSourceLocation(NNS.getLocalSourceRange().getEnd()); d5238 1 a5238 1 AddSourceLocation(NNS.getLocalSourceRange().getEnd()); d5242 2 a5243 2 AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl()); AddSourceRange(NNS.getLocalSourceRange()); d5249 1 a5249 1 void ASTRecordWriter::AddTemplateName(TemplateName Name) { d5251 1 a5251 1 Record->push_back(Kind); d5254 1 a5254 1 AddDeclRef(Name.getAsTemplateDecl()); d5259 1 a5259 1 Record->push_back(OvT->size()); d5261 1 a5261 1 AddDeclRef(I); d5267 3 a5269 3 AddNestedNameSpecifier(QualT->getQualifier()); Record->push_back(QualT->hasTemplateKeyword()); AddDeclRef(QualT->getTemplateDecl()); d5275 2 a5276 2 AddNestedNameSpecifier(DepT->getQualifier()); Record->push_back(DepT->isIdentifier()); d5278 1 a5278 1 AddIdentifierRef(DepT->getIdentifier()); d5280 1 a5280 1 Record->push_back(DepT->getOperator()); d5287 2 a5288 2 AddDeclRef(subst->getParameter()); AddTemplateName(subst->getReplacement()); d5295 2 a5296 2 AddDeclRef(SubstPack->getParameterPack()); AddTemplateArgument(SubstPack->getArgumentPack()); d5302 3 a5304 2 void ASTRecordWriter::AddTemplateArgument(const TemplateArgument &Arg) { Record->push_back(Arg.getKind()); d5309 1 a5309 1 AddTypeRef(Arg.getAsType()); d5312 2 a5313 2 AddDeclRef(Arg.getAsDecl()); AddTypeRef(Arg.getParamTypeForDecl()); d5316 1 a5316 1 AddTypeRef(Arg.getNullPtrType()); d5319 2 a5320 2 AddAPSInt(Arg.getAsIntegral()); AddTypeRef(Arg.getIntegralType()); d5323 1 a5323 1 AddTemplateName(Arg.getAsTemplateOrTemplatePattern()); d5326 1 a5326 1 AddTemplateName(Arg.getAsTemplateOrTemplatePattern()); d5328 1 a5328 1 Record->push_back(*NumExpansions + 1); d5330 1 a5330 1 Record->push_back(0); d5336 1 a5336 1 Record->push_back(Arg.pack_size()); d5338 1 a5338 1 AddTemplateArgument(P); d5343 3 a5345 2 void ASTRecordWriter::AddTemplateParameterList( const TemplateParameterList *TemplateParams) { d5347 4 a5350 5 AddSourceLocation(TemplateParams->getTemplateLoc()); AddSourceLocation(TemplateParams->getLAngleLoc()); AddSourceLocation(TemplateParams->getRAngleLoc()); // TODO: Concepts Record->push_back(TemplateParams->size()); d5352 1 a5352 1 AddDeclRef(P); d5356 3 a5358 2 void ASTRecordWriter::AddTemplateArgumentList( const TemplateArgumentList *TemplateArgs) { d5360 3 a5362 3 Record->push_back(TemplateArgs->size()); for (int i = 0, e = TemplateArgs->size(); i != e; ++i) AddTemplateArgument(TemplateArgs->get(i)); d5365 3 a5367 2 void ASTRecordWriter::AddASTTemplateArgumentListInfo( const ASTTemplateArgumentListInfo *ASTTemplArgList) { d5369 3 a5371 3 AddSourceLocation(ASTTemplArgList->LAngleLoc); AddSourceLocation(ASTTemplArgList->RAngleLoc); Record->push_back(ASTTemplArgList->NumTemplateArgs); d5373 2 a5374 2 for (int i = 0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) AddTemplateArgumentLoc(TemplArgs[i]); d5377 3 a5379 2 void ASTRecordWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set) { Record->push_back(Set.size()); d5382 2 a5383 2 AddDeclRef(I.getDecl()); Record->push_back(I.getAccess()); d5387 8 a5394 8 // FIXME: Move this out of the main ASTRecordWriter interface. void ASTRecordWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base) { Record->push_back(Base.isVirtual()); Record->push_back(Base.isBaseOfClass()); Record->push_back(Base.getAccessSpecifierAsWritten()); Record->push_back(Base.getInheritConstructors()); AddTypeSourceInfo(Base.getTypeSourceInfo()); AddSourceRange(Base.getSourceRange()); d5396 2 a5397 1 : SourceLocation()); d5400 15 a5414 5 static uint64_t EmitCXXBaseSpecifiers(ASTWriter &W, ArrayRef Bases) { ASTWriter::RecordData Record; ASTRecordWriter Writer(W, Record); Writer.push_back(Bases.size()); d5416 10 a5425 10 for (auto &Base : Bases) Writer.AddCXXBaseSpecifier(Base); return Writer.Emit(serialization::DECL_CXX_BASE_SPECIFIERS); } // FIXME: Move this out of the main ASTRecordWriter interface. void ASTRecordWriter::AddCXXBaseSpecifiers(ArrayRef Bases) { AddOffset(EmitCXXBaseSpecifiers(*Writer, Bases)); } d5427 12 a5438 6 static uint64_t EmitCXXCtorInitializers(ASTWriter &W, ArrayRef CtorInits) { ASTWriter::RecordData Record; ASTRecordWriter Writer(W, Record); Writer.push_back(CtorInits.size()); a5439 1 for (auto *Init : CtorInits) { d5441 3 a5443 3 Writer.push_back(CTOR_INITIALIZER_BASE); Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); Writer.push_back(Init->isBaseVirtual()); d5445 2 a5446 2 Writer.push_back(CTOR_INITIALIZER_DELEGATING); Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); d5448 2 a5449 2 Writer.push_back(CTOR_INITIALIZER_MEMBER); Writer.AddDeclRef(Init->getMember()); d5451 2 a5452 2 Writer.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); Writer.AddDeclRef(Init->getIndirectMember()); d5455 12 a5466 7 Writer.AddSourceLocation(Init->getMemberLocation()); Writer.AddStmt(Init->getInit()); Writer.AddSourceLocation(Init->getLParenLoc()); Writer.AddSourceLocation(Init->getRParenLoc()); Writer.push_back(Init->isWritten()); if (Init->isWritten()) Writer.push_back(Init->getSourceOrder()); d5468 4 d5473 21 a5493 2 return Writer.Emit(serialization::DECL_CXX_CTOR_INITIALIZERS); } d5495 3 a5497 4 // FIXME: Move this out of the main ASTRecordWriter interface. void ASTRecordWriter::AddCXXCtorInitializers( ArrayRef CtorInits) { AddOffset(EmitCXXCtorInitializers(*Writer, CtorInits)); d5500 1 a5500 1 void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { d5502 38 a5539 42 Record->push_back(Data.IsLambda); Record->push_back(Data.UserDeclaredConstructor); Record->push_back(Data.UserDeclaredSpecialMembers); Record->push_back(Data.Aggregate); Record->push_back(Data.PlainOldData); Record->push_back(Data.Empty); Record->push_back(Data.Polymorphic); Record->push_back(Data.Abstract); Record->push_back(Data.IsStandardLayout); Record->push_back(Data.HasNoNonEmptyBases); Record->push_back(Data.HasPrivateFields); Record->push_back(Data.HasProtectedFields); Record->push_back(Data.HasPublicFields); Record->push_back(Data.HasMutableFields); Record->push_back(Data.HasVariantMembers); Record->push_back(Data.HasOnlyCMembers); Record->push_back(Data.HasInClassInitializer); Record->push_back(Data.HasUninitializedReferenceMember); Record->push_back(Data.HasUninitializedFields); Record->push_back(Data.HasInheritedConstructor); Record->push_back(Data.HasInheritedAssignment); Record->push_back(Data.NeedOverloadResolutionForMoveConstructor); Record->push_back(Data.NeedOverloadResolutionForMoveAssignment); Record->push_back(Data.NeedOverloadResolutionForDestructor); Record->push_back(Data.DefaultedMoveConstructorIsDeleted); Record->push_back(Data.DefaultedMoveAssignmentIsDeleted); Record->push_back(Data.DefaultedDestructorIsDeleted); Record->push_back(Data.HasTrivialSpecialMembers); Record->push_back(Data.DeclaredNonTrivialSpecialMembers); Record->push_back(Data.HasIrrelevantDestructor); Record->push_back(Data.HasConstexprNonCopyMoveConstructor); Record->push_back(Data.HasDefaultedDefaultConstructor); Record->push_back(Data.DefaultedDefaultConstructorIsConstexpr); Record->push_back(Data.HasConstexprDefaultConstructor); Record->push_back(Data.HasNonLiteralTypeFieldsOrBases); Record->push_back(Data.ComputedVisibleConversions); Record->push_back(Data.UserProvidedDefaultConstructor); Record->push_back(Data.DeclaredSpecialMembers); Record->push_back(Data.ImplicitCopyConstructorHasConstParam); Record->push_back(Data.ImplicitCopyAssignmentHasConstParam); Record->push_back(Data.HasDeclaredCopyConstructorWithConstParam); Record->push_back(Data.HasDeclaredCopyAssignmentWithConstParam); d5542 1 a5542 1 Record->push_back(Data.NumBases); d5544 3 a5546 2 AddCXXBaseSpecifiers(Data.bases()); d5548 1 a5548 1 Record->push_back(Data.NumVBases); d5550 2 a5551 1 AddCXXBaseSpecifiers(Data.vbases()); d5553 2 a5554 2 AddUnresolvedSet(Data.Conversions.get(*Writer->Context)); AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context)); d5556 1 a5556 1 AddDeclRef(D->getFirstFriend()); d5561 8 a5568 8 Record->push_back(Lambda.Dependent); Record->push_back(Lambda.IsGenericLambda); Record->push_back(Lambda.CaptureDefault); Record->push_back(Lambda.NumCaptures); Record->push_back(Lambda.NumExplicitCaptures); Record->push_back(Lambda.ManglingNumber); AddDeclRef(D->getLambdaContextDecl()); AddTypeSourceInfo(Lambda.MethodTyInfo); d5571 3 a5573 3 AddSourceLocation(Capture.getLocation()); Record->push_back(Capture.isImplicit()); Record->push_back(Capture.getCaptureKind()); a5574 1 case LCK_StarThis: d5582 1 a5582 1 AddDeclRef(Var); d5584 2 a5585 1 : SourceLocation()); a5664 1 if (Chain && Chain->isProcessingUpdateRecords()) return; d5685 4 d5695 2 a5696 14 if (Chain && Chain->isProcessingUpdateRecords()) return; assert(DC->isLookupContext() && "Should not add lookup results to non-lookup contexts!"); // TU is handled elsewhere. if (isa(DC)) return; // Namespaces are handled elsewhere, except for template instantiations of // FunctionTemplateDecls in namespaces. We are interested in cases where the // local instantiations are added to an imported context. Only happens when // adding ADL lookup candidates, for example templated friends. if (isa(DC) && D->getFriendObjectKind() == Decl::FOK_None && !isa(D)) d5712 1 a5712 1 DeclsToEmitEvenIfUnreferenced.push_back(Child); d5714 1 a5714 1 DeclsToEmitEvenIfUnreferenced.push_back(D); a5717 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5734 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5748 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5758 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5767 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5776 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5784 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5796 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5804 9 void ASTWriter::DefaultMemberInitializerInstantiated(const FieldDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER, D)); } a5806 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5816 1 if (Chain && Chain->isProcessingUpdateRecords()) return; d5818 2 a5819 7 // If there is *any* declaration of the entity that's not from an AST file, // we can skip writing the update record. We make sure that isUsed() triggers // completion of the redeclaration chain of the entity. for (auto Prev = D->getMostRecentDecl(); Prev; Prev = Prev->getPreviousDecl()) if (IsLocalDecl(Prev)) return; a5824 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5831 11 void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(const Decl *D, const Attr *Attr) { if (Chain && Chain->isProcessingUpdateRecords()) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back( DeclUpdate(UPD_DECL_MARKED_OPENMP_DECLARETARGET, Attr)); } a5832 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5839 1 if (Chain && Chain->isProcessingUpdateRecords()) return; a5844 36 void ASTWriter::AddedCXXTemplateSpecialization( const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!TD->getFirstDecl()->isFromASTFile()) return; if (Chain && Chain->isProcessingUpdateRecords()) return; DeclsToEmitEvenIfUnreferenced.push_back(D); } void ASTWriter::AddedCXXTemplateSpecialization( const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!TD->getFirstDecl()->isFromASTFile()) return; if (Chain && Chain->isProcessingUpdateRecords()) return; DeclsToEmitEvenIfUnreferenced.push_back(D); } void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!TD->getFirstDecl()->isFromASTFile()) return; if (Chain && Chain->isProcessingUpdateRecords()) return; DeclsToEmitEvenIfUnreferenced.push_back(D); } @ 1.1.1.10.2.1 log @Sync with HEAD @ text @a631 1 Record.AddSourceRange(TL.getExceptionSpecRange()); d4657 11 @ 1.1.1.11 log @Import Clang 4.0RC1 r294123. @ text @a631 1 Record.AddSourceRange(TL.getExceptionSpecRange()); d4657 11 @ 1.1.1.12 log @Import clang r309604 from branches/release_50 @ text @d21 1 a22 1 #include "clang/AST/DeclContextInternals.h" d36 1 a37 2 #include "clang/Basic/LangOptions.h" #include "clang/Basic/MemoryBufferCache.h" a66 1 #include "llvm/ADT/STLExtras.h" d69 1 a75 1 #include "llvm/Support/Error.h" a80 1 #include "llvm/Support/SHA1.h" a254 1 Record.push_back(C.getNoCallerSavedRegs()); a350 9 void ASTTypeWriter::VisitDeducedTemplateSpecializationType( const DeducedTemplateSpecializationType *T) { Record.AddTemplateName(T->getTemplateName()); Record.AddTypeRef(T->getDeducedType()); if (T->getDeducedType().isNull()) Record.push_back(T->isDependentType()); Code = TYPE_DEDUCED_TEMPLATE_SPECIALIZATION; } d417 2 a418 4 Record.AddTypeRef(T->getElementType()); Record.AddStmt(T->getSizeExpr()); Record.AddSourceLocation(T->getAttributeLoc()); Code = TYPE_DEPENDENT_SIZED_EXT_VECTOR; a684 5 void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc( DeducedTemplateSpecializationTypeLoc TL) { Record.AddSourceLocation(TL.getTemplateNameLoc()); } a822 1 Abv->Add(BitCodeAbbrevOp(0)); // NoCallerSavedRegs d1004 1 d1017 1 a1031 1 RECORD(MODULAR_CODEGEN_DECLS); d1052 1 a1076 1 RECORD(PP_CONDITIONAL_STACK); a1244 5 BLOCK(UNHASHED_CONTROL_BLOCK); RECORD(SIGNATURE); RECORD(DIAGNOSTIC_OPTIONS); RECORD(DIAG_PRAGMA_MAPPINGS); d1307 5 a1311 36 ASTFileSignature ASTWriter::createSignature(StringRef Bytes) { // Calculate the hash till start of UNHASHED_CONTROL_BLOCK. llvm::SHA1 Hasher; Hasher.update(ArrayRef(Bytes.bytes_begin(), Bytes.size())); auto Hash = Hasher.result(); // Convert to an array [5*i32]. ASTFileSignature Signature; auto LShift = [&](unsigned char Val, unsigned Shift) { return (uint32_t)Val << Shift; }; for (int I = 0; I != 5; ++I) Signature[I] = LShift(Hash[I * 4 + 0], 24) | LShift(Hash[I * 4 + 1], 16) | LShift(Hash[I * 4 + 2], 8) | LShift(Hash[I * 4 + 3], 0); return Signature; } ASTFileSignature ASTWriter::writeUnhashedControlBlock(Preprocessor &PP, ASTContext &Context) { // Flush first to prepare the PCM hash (signature). Stream.FlushToWord(); auto StartOfUnhashedControl = Stream.GetCurrentBitNo() >> 3; // Enter the block and prepare to write records. RecordData Record; Stream.EnterSubblock(UNHASHED_CONTROL_BLOCK_ID, 5); // For implicit modules, write the hash of the PCM as its signature. ASTFileSignature Signature; if (WritingModule && PP.getHeaderSearchInfo().getHeaderSearchOpts().ModulesHashContent) { Signature = createSignature(StringRef(Buffer.begin(), StartOfUnhashedControl)); Record.append(Signature.begin(), Signature.end()); Stream.EmitRecord(SIGNATURE, Record); Record.clear(); a1312 24 // Diagnostic options. const auto &Diags = Context.getDiagnostics(); const DiagnosticOptions &DiagOpts = Diags.getDiagnosticOptions(); #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name); #define ENUM_DIAGOPT(Name, Type, Bits, Default) \ Record.push_back(static_cast(DiagOpts.get##Name())); #include "clang/Basic/DiagnosticOptions.def" Record.push_back(DiagOpts.Warnings.size()); for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I) AddString(DiagOpts.Warnings[I], Record); Record.push_back(DiagOpts.Remarks.size()); for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I) AddString(DiagOpts.Remarks[I], Record); // Note: we don't serialize the log or serialization file names, because they // are generally transient files and will almost always be overridden. Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record); // Write out the diagnostic/pragma mappings. WritePragmaDiagnosticMappings(Diags, /* IsModule = */ WritingModule); // Leave the options block. Stream.ExitBlock(); return Signature; d1316 6 a1321 3 void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, StringRef isysroot, const std::string &OutputFile) { d1348 10 a1358 1 if (WritingModule) { d1397 1 a1397 1 if (WritingModule && WritingModule->Kind == Module::ModuleMapModule) { d1401 3 a1403 4 AddPath(WritingModule->PresumedModuleMapFile.empty() ? Map.getModuleMapFileForUniquing(WritingModule)->getName() : StringRef(WritingModule->PresumedModuleMapFile), Record); d1423 1 a1423 1 for (ModuleFile &M : Mgr) { d1425 1 a1425 1 if (!M.isDirectlyImported()) d1428 6 a1433 12 Record.push_back((unsigned)M.Kind); // FIXME: Stable encoding AddSourceLocation(M.ImportLoc, Record); // If we have calculated signature, there is no need to store // the size or timestamp. Record.push_back(M.Signature ? 0 : M.File->getSize()); Record.push_back(M.Signature ? 0 : getTimestampForOutput(M.File)); for (auto I : M.Signature) Record.push_back(I); AddPath(M.FileName, Record); d1495 18 a1546 2 Record.push_back(HSOpts.ImplicitModuleMaps); Record.push_back(HSOpts.ModuleMapFileHomeIsCwd); d1626 1 a1636 1 bool IsTopLevelModuleMap; a1654 1 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Module map d1669 1 a1669 2 const SrcMgr::FileInfo &File = SLoc->getFile(); const SrcMgr::ContentCache *Cache = File.getContentCache(); a1677 2 Entry.IsTopLevelModuleMap = isModuleMap(File.getFileCharacteristic()) && File.getIncludeLoc().isInvalid(); d1708 1 a1708 2 Entry.IsTransient, Entry.IsTopLevelModuleMap}; d1743 1 a1743 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Characteristic d1762 1 a1762 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Characteristic d1803 1 d1810 3 a1812 2 HeaderFileInfoTrait(ASTWriter &Writer) : Writer(Writer) {} d1814 1 a1815 2 off_t Size; time_t ModTime; a1817 3 using UnresolvedModule = llvm::PointerIntPair; d1819 1 a1819 5 struct data_type { const HeaderFileInfo &HFI; ArrayRef KnownHeaders; UnresolvedModule Unresolved; }; a1820 1 d1828 2 a1829 1 return llvm::hash_combine(key.Size, key.ModTime); d1839 1 a1839 1 for (auto ModInfo : Data.KnownHeaders) a1841 2 if (Data.Unresolved.getPointer()) DataLen += 4; d1845 1 a1845 1 d1849 1 a1849 1 LE.write(key.Size); d1851 1 a1851 1 LE.write(key.ModTime); d1855 1 a1855 1 d1862 4 a1865 4 unsigned char Flags = (Data.HFI.isImport << 5) | (Data.HFI.isPragmaOnce << 4) | (Data.HFI.DirInfo << 1) | Data.HFI.IndexHeaderMapHeader; d1867 1 a1867 1 LE.write(Data.HFI.NumIncludes); d1869 2 a1870 2 if (!Data.HFI.ControllingMacro) LE.write(Data.HFI.ControllingMacroID); d1872 2 a1873 2 LE.write(Writer.getIdentifierRef(Data.HFI.ControllingMacro)); d1875 1 a1875 1 if (!Data.HFI.Framework.empty()) { d1878 1 a1878 1 = FrameworkNameOffset.find(Data.HFI.Framework); d1881 2 a1882 2 FrameworkStringData.append(Data.HFI.Framework.begin(), Data.HFI.Framework.end()); d1885 1 a1885 1 FrameworkNameOffset[Data.HFI.Framework] = Offset; d1891 6 a1896 3 auto EmitModule = [&](Module *M, ModuleMap::ModuleHeaderRole Role) { if (uint32_t ModID = Writer.getLocalOrImportedSubmoduleID(M)) { uint32_t Value = (ModID << 2) | (unsigned)Role; d1900 1 a1900 8 }; // FIXME: If the header is excluded, we should write out some // record of that fact. for (auto ModInfo : Data.KnownHeaders) EmitModule(ModInfo.getModule(), ModInfo.getRole()); if (Data.Unresolved.getPointer()) EmitModule(Data.Unresolved.getPointer(), Data.Unresolved.getInt()); a1914 60 HeaderFileInfoTrait GeneratorTrait(*this); llvm::OnDiskChainedHashTableGenerator Generator; SmallVector SavedStrings; unsigned NumHeaderSearchEntries = 0; // Find all unresolved headers for the current module. We generally will // have resolved them before we get here, but not necessarily: we might be // compiling a preprocessed module, where there is no requirement for the // original files to exist any more. const HeaderFileInfo Empty; // So we can take a reference. if (WritingModule) { llvm::SmallVector Worklist(1, WritingModule); while (!Worklist.empty()) { Module *M = Worklist.pop_back_val(); if (!M->isAvailable()) continue; // Map to disk files where possible, to pick up any missing stat // information. This also means we don't need to check the unresolved // headers list when emitting resolved headers in the first loop below. // FIXME: It'd be preferable to avoid doing this if we were given // sufficient stat information in the module map. HS.getModuleMap().resolveHeaderDirectives(M); // If the file didn't exist, we can still create a module if we were given // enough information in the module map. for (auto U : M->MissingHeaders) { // Check that we were given enough information to build a module // without this file existing on disk. if (!U.Size || (!U.ModTime && IncludeTimestamps)) { PP->Diag(U.FileNameLoc, diag::err_module_no_size_mtime_for_header) << WritingModule->getFullModuleName() << U.Size.hasValue() << U.FileName; continue; } // Form the effective relative pathname for the file. SmallString<128> Filename(M->Directory->getName()); llvm::sys::path::append(Filename, U.FileName); PreparePathForOutput(Filename); StringRef FilenameDup = strdup(Filename.c_str()); SavedStrings.push_back(FilenameDup.data()); HeaderFileInfoTrait::key_type Key = { FilenameDup, *U.Size, IncludeTimestamps ? *U.ModTime : 0 }; HeaderFileInfoTrait::data_type Data = { Empty, {}, {M, ModuleMap::headerKindToRole(U.Kind)} }; // FIXME: Deal with cases where there are multiple unresolved header // directives in different submodules for the same header. Generator.insert(Key, Data, GeneratorTrait); ++NumHeaderSearchEntries; } Worklist.append(M->submodule_begin(), M->submodule_end()); } } d1920 5 a1924 1 d1951 2 a1952 7 HeaderFileInfoTrait::key_type Key = { Filename, File->getSize(), getTimestampForOutput(File) }; HeaderFileInfoTrait::data_type Data = { *HFI, HS.getModuleMap().findAllModulesForHeader(File), {} }; Generator.insert(Key, Data, GeneratorTrait); d1955 1 a1955 1 a1988 24 static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob, unsigned SLocBufferBlobCompressedAbbrv, unsigned SLocBufferBlobAbbrv) { typedef ASTWriter::RecordData::value_type RecordDataType; // Compress the buffer if possible. We expect that almost all PCM // consumers will not want its contents. SmallString<0> CompressedBuffer; if (llvm::zlib::isAvailable()) { llvm::Error E = llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer); if (!E) { RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1}; Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, CompressedBuffer); return; } llvm::consumeError(std::move(E)); } RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB}; Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob); } d2097 14 a2110 2 emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv, SLocBufferBlobAbbrv); a2238 12 if (PP.isRecordingPreamble() && PP.hasRecordedPreamble()) { assert(!IsModule); for (const auto &Cond : PP.getPreambleConditionalStack()) { AddSourceLocation(Cond.IfLoc, Record); Record.push_back(Cond.WasSkipping); Record.push_back(Cond.FoundNonSkip); Record.push_back(Cond.FoundElse); } Stream.EmitRecord(PP_CONDITIONAL_STACK, Record); Record.clear(); } d2350 1 d2364 3 a2366 3 Record.push_back(MI->getNumParams()); for (const IdentifierInfo *Param : MI->params()) AddIdentifierRef(Param, Record); d2519 1 a2519 2 (getLangOpts().CompilingPCH || !Top->fullModuleNameIs(StringRef(getLangOpts().CurrentModule)))) d2632 3 a2634 4 RecordData::value_type Record[] = { getNumberOfModules(WritingModule), FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS, (unsigned)WritingModule->Kind}; d2653 5 a2657 11 RecordData::value_type Record[] = {SUBMODULE_DEFINITION, ID, ParentID, Mod->IsFramework, Mod->IsExplicit, Mod->IsSystem, Mod->IsExternC, Mod->InferSubmodules, Mod->InferExplicitSubmodules, Mod->InferExportWildcard, Mod->ConfigMacrosExhaustive}; d2771 19 d2792 6 d2801 1 d2803 6 d2810 2 a2811 22 auto EncodeDiagStateFlags = [](const DiagnosticsEngine::DiagState *DS) -> unsigned { unsigned Result = (unsigned)DS->ExtBehavior; for (unsigned Val : {(unsigned)DS->IgnoreAllWarnings, (unsigned)DS->EnableAllWarnings, (unsigned)DS->WarningsAsErrors, (unsigned)DS->ErrorsAsFatal, (unsigned)DS->SuppressSystemWarnings}) Result = (Result << 1) | Val; return Result; }; unsigned Flags = EncodeDiagStateFlags(Diag.DiagStatesByLoc.FirstDiagState); Record.push_back(Flags); auto AddDiagState = [&](const DiagnosticsEngine::DiagState *State, bool IncludeNonPragmaStates) { // Ensure that the diagnostic state wasn't modified since it was created. // We will not correctly round-trip this information otherwise. assert(Flags == EncodeDiagStateFlags(State) && "diag state flags vary in single AST file"); unsigned &DiagStateID = DiagStateIDMap[State]; d2813 1 a2813 1 d2816 2 a2817 6 // Add a placeholder for the number of mappings. auto SizeIdx = Record.size(); Record.emplace_back(); for (const auto &I : *State) { if (I.second.isPragma() || IncludeNonPragmaStates) { d2819 1 a2819 1 Record.push_back(I.second.serialize()); d2822 2 a2823 24 // Update the placeholder. Record[SizeIdx] = (Record.size() - SizeIdx) / 2; } }; AddDiagState(Diag.DiagStatesByLoc.FirstDiagState, isModule); // Reserve a spot for the number of locations with state transitions. auto NumLocationsIdx = Record.size(); Record.emplace_back(); // Emit the state transitions. unsigned NumLocations = 0; for (auto &FileIDAndFile : Diag.DiagStatesByLoc.Files) { if (!FileIDAndFile.first.isValid() || !FileIDAndFile.second.HasLocalTransitions) continue; ++NumLocations; AddSourceLocation(Diag.SourceMgr->getLocForStartOfFile(FileIDAndFile.first), Record); Record.push_back(FileIDAndFile.second.StateTransitions.size()); for (auto &StatePoint : FileIDAndFile.second.StateTransitions) { Record.push_back(StatePoint.Offset); AddDiagState(StatePoint.State, false); d2827 2 a2828 13 // Backpatch the number of locations. Record[NumLocationsIdx] = NumLocations; // Emit CurDiagStateLoc. Do it last in order to match source order. // // This also protects against a hypothetical corner case with simulating // -Werror settings for implicit modules in the ASTReader, where reading // CurDiagState out of context could change whether warning pragmas are // treated as errors. AddSourceLocation(Diag.DiagStatesByLoc.CurDiagStateLoc, Record); AddDiagState(Diag.DiagStatesByLoc.CurDiagState, false); Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); a3561 1 case DeclarationName::CXXDeductionGuideName: a3590 1 case DeclarationName::CXXDeductionGuideName: d3934 1 a3934 1 RecordData::value_type Record[] = {Opts.getInt()}; a4088 19 /// \brief Write the state of 'pragma pack' at the end of the module. void ASTWriter::WritePackPragmaOptions(Sema &SemaRef) { // Don't serialize pragma pack state for modules, since it should only take // effect on a per-submodule basis. if (WritingModule) return; RecordData Record; Record.push_back(SemaRef.PackStack.CurrentValue); AddSourceLocation(SemaRef.PackStack.CurrentPragmaLocation, Record); Record.push_back(SemaRef.PackStack.Stack.size()); for (const auto &StackEntry : SemaRef.PackStack.Stack) { Record.push_back(StackEntry.Value); AddSourceLocation(StackEntry.PragmaLocation, Record); AddString(StackEntry.StackSlotLabel, Record); } Stream.EmitRecord(PACK_PRAGMA_OPTIONS, Record); } a4225 1 SmallVectorImpl &Buffer, MemoryBufferCache &PCMCache, d4228 1 a4228 2 : Stream(Stream), Buffer(Buffer), PCMCache(PCMCache), IncludeTimestamps(IncludeTimestamps) { d4248 3 a4250 4 ASTFileSignature ASTWriter::WriteAST(Sema &SemaRef, const std::string &OutputFile, Module *WritingModule, StringRef isysroot, bool hasErrors) { a4273 6 if (SemaRef.Context.getLangOpts().ImplicitModules && WritingModule) { // Construct MemoryBuffer and update buffer manager. PCMCache.addBuffer(OutputFile, llvm::MemoryBuffer::getMemBufferCopy( StringRef(Buffer.begin(), Buffer.size()))); } d4286 3 a4288 3 ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, const std::string &OutputFile, Module *WritingModule) { d4436 1 a4436 1 WriteControlBlock(PP, Context, isysroot, OutputFile); d4576 1 a4576 1 for (ModuleFile &M : Chain->ModuleMgr) { d4579 1 a4579 1 StringRef FileName = M.FileName; d4597 9 a4605 9 writeBaseIDOrNone(M.SLocEntryBaseOffset, M.LocalNumSLocEntries); writeBaseIDOrNone(M.BaseIdentifierID, M.LocalNumIdentifiers); writeBaseIDOrNone(M.BaseMacroID, M.LocalNumMacros); writeBaseIDOrNone(M.BasePreprocessedEntityID, M.NumPreprocessedEntities); writeBaseIDOrNone(M.BaseSubmoduleID, M.LocalNumSubmodules); writeBaseIDOrNone(M.BaseSelectorID, M.LocalNumSelectors); writeBaseIDOrNone(M.BaseDeclID, M.LocalNumDecls); writeBaseIDOrNone(M.BaseTypeIndex, M.LocalNumTypes); d4653 1 a4664 3 if (!ModularCodegenDecls.empty()) Stream.EmitRecord(MODULAR_CODEGEN_DECLS, ModularCodegenDecls); a4767 1 WritePackPragmaOptions(SemaRef); d4779 1 a4779 1 return writeUnhashedControlBlock(PP, Context); d4816 1 a4816 2 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: { const VarDecl *VD = cast(D); a4817 7 if (VD->getInit()) { Record.push_back(!VD->isInitKnownICE() ? 1 : (VD->isInitICE() ? 3 : 2)); Record.AddStmt(const_cast(VD->getInit())); } else { Record.push_back(0); } a4818 1 } a5231 4 case DeclarationName::CXXDeductionGuideName: AddDeclRef(Name.getCXXDeductionGuideTemplate()); break; a5292 1 case DeclarationName::CXXDeductionGuideName: d5654 1 a5654 2 Record->push_back(Data.ImplicitCopyConstructorCanHaveConstParamForVBase); Record->push_back(Data.ImplicitCopyConstructorCanHaveConstParamForNonVBase); a5657 9 // getODRHash will compute the ODRHash if it has not been previously computed. Record->push_back(D->getODRHash()); bool ModulesDebugInfo = Writer->Context->getLangOpts().ModulesDebugInfo && Writer->WritingModule && !D->isDependentType(); Record->push_back(ModulesDebugInfo); if (ModulesDebugInfo) Writer->ModularCodegenDecls.push_back(Writer->GetDeclRef(D)); @ 1.1.1.13 log @Import clang r319952 from branches/release_50 @ text @a5876 1 Record->push_back(Data.NeedOverloadResolutionForCopyConstructor); a5879 1 Record->push_back(Data.DefaultedCopyConstructorIsDeleted); a5887 1 Record->push_back(Data.CanPassInRegisters); @ 1.1.1.13.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ASTWriter.cpp - AST File Writer ------------------------------------===// a19 1 #include "clang/AST/Attr.h" a20 1 #include "clang/AST/DeclBase.h" a23 1 #include "clang/AST/DeclObjC.h" a24 1 #include "clang/AST/DeclarationName.h" a32 1 #include "clang/Basic/Diagnostic.h" a35 1 #include "clang/Basic/IdentifierTable.h" a36 1 #include "clang/Basic/Lambda.h" a40 2 #include "clang/Basic/OpenCLOptions.h" #include "clang/Basic/SourceLocation.h" a42 1 #include "clang/Basic/Specifiers.h" d46 1 a64 3 #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" d66 1 a67 1 #include "llvm/ADT/PointerIntPair.h" a68 1 #include "llvm/ADT/ScopeExit.h" d71 1 a71 3 #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" a75 2 #include "llvm/Support/DJB.h" #include "llvm/Support/Endian.h" d82 1 a83 1 #include "llvm/Support/VersionTuple.h" a89 1 #include d92 1 a92 2 #include #include a94 1 #include d122 4 a125 5 /// Type code that corresponds to the record generated. TypeCode Code = static_cast(0); /// Abbreviation to use for the record, if any. unsigned AbbrevToUse = 0; d129 1 a129 1 : Writer(Writer), Record(Writer, Record) {} d163 1 a163 1 } // namespace clang a258 1 Record.push_back(C.getNoCfCheck()); d276 1 a276 1 } else if (isComputedNoexcept(T->getExceptionSpecType())) { a435 17 void ASTTypeWriter::VisitDependentVectorType(const DependentVectorType *T) { Record.AddTypeRef(T->getElementType()); Record.AddStmt(const_cast(T->getSizeExpr())); Record.AddSourceLocation(T->getAttributeLoc()); Record.push_back(T->getVectorKind()); Code = TYPE_DEPENDENT_SIZED_VECTOR; } void ASTTypeWriter::VisitDependentAddressSpaceType( const DependentAddressSpaceType *T) { Record.AddTypeRef(T->getPointeeType()); Record.AddStmt(T->getAddrSpaceExpr()); Record.AddSourceLocation(T->getAttributeLoc()); Code = TYPE_DEPENDENT_ADDRESS_SPACE; } a484 1 Record.AddDeclRef(T->getOwnedTagDecl()); d544 2 a545 1 TypeLocWriter(ASTRecordWriter &Record) : Record(Record) {} d556 1 a556 1 } // namespace a629 9 void TypeLocWriter::VisitDependentAddressSpaceTypeLoc( DependentAddressSpaceTypeLoc TL) { Record.AddSourceLocation(TL.getAttrNameLoc()); SourceRange range = TL.getAttrOperandParensRange(); Record.AddSourceLocation(range.getBegin()); Record.AddSourceLocation(range.getEnd()); Record.AddStmt(TL.getAttrExprOperand()); } a638 5 void TypeLocWriter::VisitDependentVectorTypeLoc( DependentVectorTypeLoc TL) { Record.AddSourceLocation(TL.getNameLoc()); } a651 1 a654 1 a657 1 a660 1 a663 1 a671 1 a843 1 Abv->Add(BitCodeAbbrevOp(0)); // NoCfCheck a1063 1 RECORD(PPD_SKIPPED_RANGES); a1132 1 RECORD(SUBMODULE_EXPORT_AS); d1252 1 a1252 1 d1275 1 a1275 1 /// Prepares a path for being written to an AST file by converting it d1285 1 a1285 1 /// Adjusts the given filename to only write out the portion of the d1395 1 a1395 1 /// Write the control block. a1399 1 d1402 1 a1402 1 a1411 1 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PCHHasObjectFile d1418 4 a1421 10 RecordData::value_type Record[] = { METADATA, VERSION_MAJOR, VERSION_MINOR, CLANG_VERSION_MAJOR, CLANG_VERSION_MINOR, !isysroot.empty(), IncludeTimestamps, Context.getLangOpts().BuildingPCHWithObjectFile, ASTHasCompilerErrors}; a1507 1 AddString(M.ModuleName, Record); d1689 8 a1696 8 /// An input file. struct InputFileEntry { const FileEntry *File; bool IsSystemFile; bool IsTransient; bool BufferOverridden; bool IsTopLevelModuleMap; }; d1698 1 a1698 1 } // namespace a1703 1 d1798 1 a1798 1 /// Create an abbreviation for the SLocEntry that refers to a d1817 1 a1817 1 /// Create an abbreviation for the SLocEntry that refers to a d1832 1 a1832 1 /// Create an abbreviation for the SLocEntry that refers to a d1847 1 a1847 1 /// Create an abbreviation for the SLocEntry that refers to a macro a1857 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is token range d1867 1 a1867 1 d1871 1 a1871 1 d1880 1 a1880 1 using key_type_ref = const key_type &; d1884 1 a1884 1 d1890 1 a1890 4 using data_type_ref = const data_type &; using hash_value_type = unsigned; using offset_type = unsigned; d1892 3 d1901 2 a1902 2 std::pair d1905 1 a1905 2 endian::Writer LE(Out, little); d1920 1 a1920 2 endian::Writer LE(Out, little); d1931 1 a1931 2 endian::Writer LE(Out, little); d1933 1 a1933 1 d1940 1 a1940 1 d1953 1 a1953 1 FrameworkStringData.append(Data.HFI.Framework.begin(), d1956 1 a1956 1 d1980 1 a1980 1 d1985 1 a1985 1 } // namespace d1987 1 a1987 1 /// Write the header search block for the list of files that d2053 1 a2053 1 a2097 1 d2100 1 a2100 1 endian::write(Out, 0, little); d2114 1 a2114 1 d2120 1 a2120 1 d2129 1 a2129 1 using RecordDataType = ASTWriter::RecordData::value_type; d2150 1 a2150 1 /// Writes the block containing the serialized form of the d2220 1 a2220 1 d2229 1 a2229 1 d2231 1 a2231 1 a2269 1 Record.push_back(Expansion.isExpansionTokenRange()); a2314 1 FilenameMap[-1] = -1; // For unspecified filenames. d2320 1 a2320 1 FilenameMap.size() - 1)).second) d2371 1 a2371 1 /// Writes the block containing the serialized form of the d2373 1 a2389 11 auto SkipInfo = PP.getPreambleSkipInfo(); if (SkipInfo.hasValue()) { Record.push_back(true); AddSourceLocation(SkipInfo->HashTokenLoc, Record); AddSourceLocation(SkipInfo->IfTokenLoc, Record); Record.push_back(SkipInfo->FoundNonSkipPortion); Record.push_back(SkipInfo->FoundElse); AddSourceLocation(SkipInfo->ElseLoc, Record); } else { Record.push_back(false); } d2421 2 a2422 2 llvm::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), llvm::less_ptr()); d2481 1 a2481 1 /// Offsets of each of the macros into the bitstream, indexed by d2581 2 a2582 2 // Set up the abbreviation for d2594 3 a2596 3 unsigned FirstPreprocessorEntityID = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) d2602 1 a2602 1 E != EEnd; d2643 1 a2643 1 a2666 20 // Write the skipped region table for the preprocessing record. ArrayRef SkippedRanges = PPRec.getSkippedRanges(); if (SkippedRanges.size() > 0) { std::vector SerializedSkippedRanges; SerializedSkippedRanges.reserve(SkippedRanges.size()); for (auto const& Range : SkippedRanges) SerializedSkippedRanges.emplace_back(Range); using namespace llvm; auto Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(PPD_SKIPPED_RANGES)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); Record.clear(); Record.push_back(PPD_SKIPPED_RANGES); Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev, Record, bytes(SerializedSkippedRanges)); } d2696 1 a2696 1 /// Compute the number of modules within the given tree (including the d2703 1 a2703 1 d2710 1 a2710 1 a2717 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind a2725 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModuleMapIsPriv... a2791 5 Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXPORT_AS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2795 2 a2796 1 FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS}; d2798 1 a2798 1 a2817 1 (RecordData::value_type)Mod->Kind, d2825 1 a2825 2 Mod->ConfigMacrosExhaustive, Mod->ModuleMapIsPrivate}; d2873 1 a2873 1 // Emit the imports. d2881 1 a2881 1 // Emit the exports. a2925 6 // Emit the name of the re-exported module, if any. if (!Mod->ExportAsModule.empty()) { RecordData::value_type Record[] = {SUBMODULE_EXPORT_AS}; Stream.EmitRecordWithBlob(ExportAsAbbrev, Record, Mod->ExportAsModule); } d2930 1 a2930 1 d2969 1 a2969 1 d3000 2 a3001 5 SourceLocation Loc = Diag.SourceMgr->getComposedLoc(FileIDAndFile.first, 0); assert(!Loc.isInvalid() && "start loc for valid FileID is invalid"); AddSourceLocation(Loc, Record); d3028 1 a3028 1 /// Write the representation of a type to the AST stream. d3060 1 a3060 1 /// Write the block containing all of the declaration IDs d3064 1 a3064 1 /// bitstream, or 0 if no block was written. d3119 2 a3120 2 llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), llvm::less_first()); a3142 3 auto _ = llvm::make_scope_exit([this] { Stream.ExitBlock(); }); if (!PP->getPreprocessorOpts().WriteCommentListToPCH) return; d3153 1 d3167 2 a3168 2 using key_type = Selector; using key_type_ref = key_type; d3174 1 a3174 1 using data_type_ref = const data_type &; d3176 2 a3177 2 using hash_value_type = unsigned; using offset_type = unsigned; d3179 1 a3179 1 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) {} d3185 1 a3185 1 std::pair d3189 1 a3189 2 endian::Writer LE(Out, little); d3207 1 a3207 2 endian::Writer LE(Out, little); d3223 1 a3223 2 endian::Writer LE(Out, little); d3267 1 a3267 1 } // namespace d3269 1 a3269 1 /// Write ObjC data: selectors and the method pool. a3330 1 d3334 1 a3334 1 endian::write(Out, 0, little); d3372 1 a3372 1 /// Write the selectors referenced in @@selector expression into AST file. a3374 1 d3446 2 a3447 2 /// Determines whether this is an "interesting" identifier that needs a d3463 2 a3464 2 using key_type = IdentifierInfo *; using key_type_ref = key_type; d3466 2 a3467 2 using data_type = IdentID; using data_type_ref = data_type; d3469 2 a3470 2 using hash_value_type = unsigned; using offset_type = unsigned; d3482 1 a3482 1 return llvm::djbHash(II->getName()); d3494 1 a3494 1 std::pair a3511 1 d3513 1 a3513 2 endian::Writer LE(Out, little); d3541 1 a3541 2 endian::Writer LE(Out, little); d3584 1 a3584 1 } // namespace d3586 1 a3586 1 /// Write the identifier table into the AST file. d3591 1 a3591 1 void ASTWriter::WriteIdentifierTable(Preprocessor &PP, d3616 1 a3616 1 llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); a3641 1 d3644 1 a3644 1 endian::write(Out, 0, little); d3697 2 a3698 2 using key_type = DeclarationNameKey; using key_type_ref = key_type; d3701 2 a3702 2 using data_type = std::pair; using data_type_ref = const data_type &; d3704 2 a3705 2 using hash_value_type = unsigned; using offset_type = unsigned; d3707 1 a3707 1 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) {} d3739 2 a3740 2 endian::write(Out, Writer.getChain()->getModuleFileID(F), little); d3747 1 a3747 2 endian::Writer LE(Out, little); d3780 1 a3780 2 endian::Writer LE(Out, little); d3811 1 a3811 2 endian::Writer LE(Out, little); d3819 1 a3819 1 } // namespace d3909 1 a3909 1 llvm::sort(Names.begin(), Names.end()); d4012 1 a4012 1 /// Write the block containing all of the declaration IDs d4046 1 a4046 1 llvm::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); d4102 1 a4102 1 /// Write an UPDATE_VISIBLE block for the given context. d4127 1 a4127 1 /// Write an FP_PRAGMA_OPTIONS block for the given FPOptions. d4133 1 a4133 1 /// Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. d4190 1 a4190 1 d4194 1 a4194 1 d4196 1 a4196 1 d4199 1 a4199 1 d4208 1 a4208 1 d4211 1 a4211 1 d4260 1 a4260 1 /// Write the state of 'pragma clang optimize' at the end of the module. d4268 1 a4268 1 /// Write the state of 'pragma ms_struct' at the end of the module. d4275 1 a4275 1 /// Write the state of 'pragma pointers_to_members' at the end of the d4284 1 a4284 1 /// Write the state of 'pragma pack' at the end of the module. a4297 1 AddSourceLocation(StackEntry.PragmaPushLocation, Record); d4342 1 a4342 1 /// Emit the list of attributes to the specified record. d4351 1 d4417 1 a4417 1 /// Note that the identifier II occurs at the given offset d4427 1 a4427 1 /// Note that the selector Sel occurs at the given offset d4471 1 a4471 1 d4519 1 a4519 1 d4560 1 a4560 1 d4648 7 a4654 9 if (!isModule) { for (const auto &DeleteExprsInfo : SemaRef.getMismatchingDeleteExpressions()) { AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size()); for (const auto &DeleteLoc : DeleteExprsInfo.second) { AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteLoc.second); } d4681 1 a4681 1 d4703 1 a4703 1 d4742 1 a4742 1 llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); d4781 1 a4781 2 // *(module-kind:i8 // module-name-len:i16 module-name:len*i8 d4791 1 a4791 4 // // module-kind is the ModuleKind enum value. If it is MK_PrebuiltModule or // MK_ExplicitModule, then the module-name is the module name. Otherwise, // it is the module file name. d4801 4 a4804 9 endian::Writer LE(Out, little); LE.write(static_cast(M.Kind)); StringRef Name = M.Kind == MK_PrebuiltModule || M.Kind == MK_ExplicitModule ? M.ModuleName : M.FileName; LE.write(Name.size()); Out.write(Name.data(), Name.size()); d4877 1 a4877 1 // If we're emitting a module, write out the submodule information. d4927 1 a4927 1 d4970 1 a4970 1 llvm::sort(Imports.begin(), Imports.end(), Cmp); d5042 2 a5043 2 case UPD_CXX_POINT_OF_INSTANTIATION: // FIXME: Do we need to also save the template specialization kind here? a5044 6 break; case UPD_CXX_ADDED_VAR_DEFINITION: { const VarDecl *VD = cast(D); Record.push_back(VD->isInline()); Record.push_back(VD->isInlineSpecified()); a5067 2 Record.push_back(RD->isParamDestroyedInCallee()); Record.push_back(RD->getArgPassingRestrictions()); a5111 1 Record.AddStmt(cast(D)->getOperatorDeleteThisArg()); d5223 1 a5223 1 a5305 1 AddTypeRef(TInfo->getType()); d5310 2 d5367 1 a5367 1 d5372 1 a5372 1 d5416 1 a5416 3 // TemplateTemplateParmDecls that are part of an alias template, should not // have TU as lexical context. if (isa(D) || isa(D)) a5633 1 AddTypeRef(NNS.getTypeLoc().getType()); d5692 1 a5692 1 d5755 1 a5755 1 /// Emit a template argument list. d5792 1 a5792 1 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() d5865 1 a5865 3 Record->push_back(Data.IsCXX11StandardLayout); Record->push_back(Data.HasBasesWithFields); Record->push_back(Data.HasBasesWithNonStaticDataMembers); a5885 1 Record->push_back(Data.HasTrivialSpecialMembersForCall); a5886 1 Record->push_back(Data.DeclaredNonTrivialSpecialMembersForCall); d5890 1 d5924 1 a5924 1 // Data.Definition is the owning decl, no need to write it. d5926 1 a5926 1 d6139 1 a6139 2 const FunctionDecl *Delete, Expr *ThisArg) { a6158 9 void ASTWriter::VariableDefinitionInstantiated(const VarDecl *D) { if (Chain && Chain->isProcessingUpdateRecords()) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_VAR_DEFINITION)); } d6168 1 a6168 1 void ASTWriter::InstantiationRequested(const ValueDecl *D) { d6176 3 a6178 6 SourceLocation POI; if (auto *VD = dyn_cast(D)) POI = VD->getPointOfInstantiation(); else POI = cast(D)->getPointOfInstantiation(); DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_POINT_OF_INSTANTIATION, POI)); d6206 1 a6206 1 @ 1.1.1.13.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.13.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ASTWriter.cpp - AST File Writer ------------------------------------===// a19 1 #include "clang/AST/Attr.h" a20 1 #include "clang/AST/DeclBase.h" a23 1 #include "clang/AST/DeclObjC.h" a24 1 #include "clang/AST/DeclarationName.h" a32 1 #include "clang/Basic/Diagnostic.h" a35 1 #include "clang/Basic/IdentifierTable.h" a36 1 #include "clang/Basic/Lambda.h" a40 2 #include "clang/Basic/OpenCLOptions.h" #include "clang/Basic/SourceLocation.h" a42 1 #include "clang/Basic/Specifiers.h" d46 1 a64 3 #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" d66 1 a67 1 #include "llvm/ADT/PointerIntPair.h" a68 1 #include "llvm/ADT/ScopeExit.h" d71 1 a71 3 #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" a75 2 #include "llvm/Support/DJB.h" #include "llvm/Support/Endian.h" d82 1 a83 1 #include "llvm/Support/VersionTuple.h" a89 1 #include d92 1 a92 2 #include #include a94 1 #include d122 4 a125 5 /// Type code that corresponds to the record generated. TypeCode Code = static_cast(0); /// Abbreviation to use for the record, if any. unsigned AbbrevToUse = 0; d129 1 a129 1 : Writer(Writer), Record(Writer, Record) {} d163 1 a163 1 } // namespace clang a258 1 Record.push_back(C.getNoCfCheck()); d276 1 a276 1 } else if (isComputedNoexcept(T->getExceptionSpecType())) { a435 17 void ASTTypeWriter::VisitDependentVectorType(const DependentVectorType *T) { Record.AddTypeRef(T->getElementType()); Record.AddStmt(const_cast(T->getSizeExpr())); Record.AddSourceLocation(T->getAttributeLoc()); Record.push_back(T->getVectorKind()); Code = TYPE_DEPENDENT_SIZED_VECTOR; } void ASTTypeWriter::VisitDependentAddressSpaceType( const DependentAddressSpaceType *T) { Record.AddTypeRef(T->getPointeeType()); Record.AddStmt(T->getAddrSpaceExpr()); Record.AddSourceLocation(T->getAttributeLoc()); Code = TYPE_DEPENDENT_ADDRESS_SPACE; } a484 1 Record.AddDeclRef(T->getOwnedTagDecl()); d544 2 a545 1 TypeLocWriter(ASTRecordWriter &Record) : Record(Record) {} d556 1 a556 1 } // namespace a629 9 void TypeLocWriter::VisitDependentAddressSpaceTypeLoc( DependentAddressSpaceTypeLoc TL) { Record.AddSourceLocation(TL.getAttrNameLoc()); SourceRange range = TL.getAttrOperandParensRange(); Record.AddSourceLocation(range.getBegin()); Record.AddSourceLocation(range.getEnd()); Record.AddStmt(TL.getAttrExprOperand()); } a638 5 void TypeLocWriter::VisitDependentVectorTypeLoc( DependentVectorTypeLoc TL) { Record.AddSourceLocation(TL.getNameLoc()); } a651 1 a654 1 a657 1 a660 1 a663 1 a671 1 a843 1 Abv->Add(BitCodeAbbrevOp(0)); // NoCfCheck a1063 1 RECORD(PPD_SKIPPED_RANGES); a1132 1 RECORD(SUBMODULE_EXPORT_AS); d1252 1 a1252 1 d1275 1 a1275 1 /// Prepares a path for being written to an AST file by converting it d1285 1 a1285 1 /// Adjusts the given filename to only write out the portion of the d1395 1 a1395 1 /// Write the control block. a1399 1 d1402 1 a1402 1 a1411 1 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PCHHasObjectFile d1418 4 a1421 10 RecordData::value_type Record[] = { METADATA, VERSION_MAJOR, VERSION_MINOR, CLANG_VERSION_MAJOR, CLANG_VERSION_MINOR, !isysroot.empty(), IncludeTimestamps, Context.getLangOpts().BuildingPCHWithObjectFile, ASTHasCompilerErrors}; a1507 1 AddString(M.ModuleName, Record); d1689 8 a1696 8 /// An input file. struct InputFileEntry { const FileEntry *File; bool IsSystemFile; bool IsTransient; bool BufferOverridden; bool IsTopLevelModuleMap; }; d1698 1 a1698 1 } // namespace a1703 1 d1798 1 a1798 1 /// Create an abbreviation for the SLocEntry that refers to a d1817 1 a1817 1 /// Create an abbreviation for the SLocEntry that refers to a d1832 1 a1832 1 /// Create an abbreviation for the SLocEntry that refers to a d1847 1 a1847 1 /// Create an abbreviation for the SLocEntry that refers to a macro a1857 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is token range d1867 1 a1867 1 d1871 1 a1871 1 d1880 1 a1880 1 using key_type_ref = const key_type &; d1884 1 a1884 1 d1890 1 a1890 4 using data_type_ref = const data_type &; using hash_value_type = unsigned; using offset_type = unsigned; d1892 3 d1901 2 a1902 2 std::pair d1905 1 a1905 2 endian::Writer LE(Out, little); d1920 1 a1920 2 endian::Writer LE(Out, little); d1931 1 a1931 2 endian::Writer LE(Out, little); d1933 1 a1933 1 d1940 1 a1940 1 d1953 1 a1953 1 FrameworkStringData.append(Data.HFI.Framework.begin(), d1956 1 a1956 1 d1980 1 a1980 1 d1985 1 a1985 1 } // namespace d1987 1 a1987 1 /// Write the header search block for the list of files that d2053 1 a2053 1 a2097 1 d2100 1 a2100 1 endian::write(Out, 0, little); d2114 1 a2114 1 d2120 1 a2120 1 d2129 1 a2129 1 using RecordDataType = ASTWriter::RecordData::value_type; d2150 1 a2150 1 /// Writes the block containing the serialized form of the d2220 1 a2220 1 d2229 1 a2229 1 d2231 1 a2231 1 a2269 1 Record.push_back(Expansion.isExpansionTokenRange()); a2314 1 FilenameMap[-1] = -1; // For unspecified filenames. d2320 1 a2320 1 FilenameMap.size() - 1)).second) d2371 1 a2371 1 /// Writes the block containing the serialized form of the d2373 1 a2389 11 auto SkipInfo = PP.getPreambleSkipInfo(); if (SkipInfo.hasValue()) { Record.push_back(true); AddSourceLocation(SkipInfo->HashTokenLoc, Record); AddSourceLocation(SkipInfo->IfTokenLoc, Record); Record.push_back(SkipInfo->FoundNonSkipPortion); Record.push_back(SkipInfo->FoundElse); AddSourceLocation(SkipInfo->ElseLoc, Record); } else { Record.push_back(false); } d2421 2 a2422 2 llvm::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), llvm::less_ptr()); d2481 1 a2481 1 /// Offsets of each of the macros into the bitstream, indexed by d2581 2 a2582 2 // Set up the abbreviation for d2594 3 a2596 3 unsigned FirstPreprocessorEntityID = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) d2602 1 a2602 1 E != EEnd; d2643 1 a2643 1 a2666 20 // Write the skipped region table for the preprocessing record. ArrayRef SkippedRanges = PPRec.getSkippedRanges(); if (SkippedRanges.size() > 0) { std::vector SerializedSkippedRanges; SerializedSkippedRanges.reserve(SkippedRanges.size()); for (auto const& Range : SkippedRanges) SerializedSkippedRanges.emplace_back(Range); using namespace llvm; auto Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(PPD_SKIPPED_RANGES)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); Record.clear(); Record.push_back(PPD_SKIPPED_RANGES); Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev, Record, bytes(SerializedSkippedRanges)); } d2696 1 a2696 1 /// Compute the number of modules within the given tree (including the d2703 1 a2703 1 d2710 1 a2710 1 a2717 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind a2725 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModuleMapIsPriv... a2791 5 Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXPORT_AS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2795 2 a2796 1 FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS}; d2798 1 a2798 1 a2817 1 (RecordData::value_type)Mod->Kind, d2825 1 a2825 2 Mod->ConfigMacrosExhaustive, Mod->ModuleMapIsPrivate}; d2873 1 a2873 1 // Emit the imports. d2881 1 a2881 1 // Emit the exports. a2925 6 // Emit the name of the re-exported module, if any. if (!Mod->ExportAsModule.empty()) { RecordData::value_type Record[] = {SUBMODULE_EXPORT_AS}; Stream.EmitRecordWithBlob(ExportAsAbbrev, Record, Mod->ExportAsModule); } d2930 1 a2930 1 d2969 1 a2969 1 d3000 2 a3001 5 SourceLocation Loc = Diag.SourceMgr->getComposedLoc(FileIDAndFile.first, 0); assert(!Loc.isInvalid() && "start loc for valid FileID is invalid"); AddSourceLocation(Loc, Record); d3028 1 a3028 1 /// Write the representation of a type to the AST stream. d3060 1 a3060 1 /// Write the block containing all of the declaration IDs d3064 1 a3064 1 /// bitstream, or 0 if no block was written. d3119 2 a3120 2 llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), llvm::less_first()); a3142 3 auto _ = llvm::make_scope_exit([this] { Stream.ExitBlock(); }); if (!PP->getPreprocessorOpts().WriteCommentListToPCH) return; d3153 1 d3167 2 a3168 2 using key_type = Selector; using key_type_ref = key_type; d3174 1 a3174 1 using data_type_ref = const data_type &; d3176 2 a3177 2 using hash_value_type = unsigned; using offset_type = unsigned; d3179 1 a3179 1 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) {} d3185 1 a3185 1 std::pair d3189 1 a3189 2 endian::Writer LE(Out, little); d3207 1 a3207 2 endian::Writer LE(Out, little); d3223 1 a3223 2 endian::Writer LE(Out, little); d3267 1 a3267 1 } // namespace d3269 1 a3269 1 /// Write ObjC data: selectors and the method pool. a3330 1 d3334 1 a3334 1 endian::write(Out, 0, little); d3372 1 a3372 1 /// Write the selectors referenced in @@selector expression into AST file. a3374 1 d3446 2 a3447 2 /// Determines whether this is an "interesting" identifier that needs a d3463 2 a3464 2 using key_type = IdentifierInfo *; using key_type_ref = key_type; d3466 2 a3467 2 using data_type = IdentID; using data_type_ref = data_type; d3469 2 a3470 2 using hash_value_type = unsigned; using offset_type = unsigned; d3482 1 a3482 1 return llvm::djbHash(II->getName()); d3494 1 a3494 1 std::pair a3511 1 d3513 1 a3513 2 endian::Writer LE(Out, little); d3541 1 a3541 2 endian::Writer LE(Out, little); d3584 1 a3584 1 } // namespace d3586 1 a3586 1 /// Write the identifier table into the AST file. d3591 1 a3591 1 void ASTWriter::WriteIdentifierTable(Preprocessor &PP, d3616 1 a3616 1 llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); a3641 1 d3644 1 a3644 1 endian::write(Out, 0, little); d3697 2 a3698 2 using key_type = DeclarationNameKey; using key_type_ref = key_type; d3701 2 a3702 2 using data_type = std::pair; using data_type_ref = const data_type &; d3704 2 a3705 2 using hash_value_type = unsigned; using offset_type = unsigned; d3707 1 a3707 1 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) {} d3739 2 a3740 2 endian::write(Out, Writer.getChain()->getModuleFileID(F), little); d3747 1 a3747 2 endian::Writer LE(Out, little); d3780 1 a3780 2 endian::Writer LE(Out, little); d3811 1 a3811 2 endian::Writer LE(Out, little); d3819 1 a3819 1 } // namespace d3909 1 a3909 1 llvm::sort(Names.begin(), Names.end()); d4012 1 a4012 1 /// Write the block containing all of the declaration IDs d4046 1 a4046 1 llvm::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); d4102 1 a4102 1 /// Write an UPDATE_VISIBLE block for the given context. d4127 1 a4127 1 /// Write an FP_PRAGMA_OPTIONS block for the given FPOptions. d4133 1 a4133 1 /// Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. d4190 1 a4190 1 d4194 1 a4194 1 d4196 1 a4196 1 d4199 1 a4199 1 d4208 1 a4208 1 d4211 1 a4211 1 d4260 1 a4260 1 /// Write the state of 'pragma clang optimize' at the end of the module. d4268 1 a4268 1 /// Write the state of 'pragma ms_struct' at the end of the module. d4275 1 a4275 1 /// Write the state of 'pragma pointers_to_members' at the end of the d4284 1 a4284 1 /// Write the state of 'pragma pack' at the end of the module. a4297 1 AddSourceLocation(StackEntry.PragmaPushLocation, Record); d4342 1 a4342 1 /// Emit the list of attributes to the specified record. d4351 1 d4417 1 a4417 1 /// Note that the identifier II occurs at the given offset d4427 1 a4427 1 /// Note that the selector Sel occurs at the given offset d4471 1 a4471 1 d4519 1 a4519 1 d4560 1 a4560 1 d4648 7 a4654 9 if (!isModule) { for (const auto &DeleteExprsInfo : SemaRef.getMismatchingDeleteExpressions()) { AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size()); for (const auto &DeleteLoc : DeleteExprsInfo.second) { AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteLoc.second); } d4681 1 a4681 1 d4703 1 a4703 1 d4742 1 a4742 1 llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); d4781 1 a4781 2 // *(module-kind:i8 // module-name-len:i16 module-name:len*i8 d4791 1 a4791 4 // // module-kind is the ModuleKind enum value. If it is MK_PrebuiltModule or // MK_ExplicitModule, then the module-name is the module name. Otherwise, // it is the module file name. d4801 4 a4804 9 endian::Writer LE(Out, little); LE.write(static_cast(M.Kind)); StringRef Name = M.Kind == MK_PrebuiltModule || M.Kind == MK_ExplicitModule ? M.ModuleName : M.FileName; LE.write(Name.size()); Out.write(Name.data(), Name.size()); d4877 1 a4877 1 // If we're emitting a module, write out the submodule information. d4927 1 a4927 1 d4970 1 a4970 1 llvm::sort(Imports.begin(), Imports.end(), Cmp); d5042 2 a5043 2 case UPD_CXX_POINT_OF_INSTANTIATION: // FIXME: Do we need to also save the template specialization kind here? a5044 6 break; case UPD_CXX_ADDED_VAR_DEFINITION: { const VarDecl *VD = cast(D); Record.push_back(VD->isInline()); Record.push_back(VD->isInlineSpecified()); a5067 2 Record.push_back(RD->isParamDestroyedInCallee()); Record.push_back(RD->getArgPassingRestrictions()); a5111 1 Record.AddStmt(cast(D)->getOperatorDeleteThisArg()); d5223 1 a5223 1 a5305 1 AddTypeRef(TInfo->getType()); d5310 2 d5367 1 a5367 1 d5372 1 a5372 1 d5416 1 a5416 3 // TemplateTemplateParmDecls that are part of an alias template, should not // have TU as lexical context. if (isa(D) || isa(D)) a5633 1 AddTypeRef(NNS.getTypeLoc().getType()); d5692 1 a5692 1 d5755 1 a5755 1 /// Emit a template argument list. d5792 1 a5792 1 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() d5865 1 a5865 3 Record->push_back(Data.IsCXX11StandardLayout); Record->push_back(Data.HasBasesWithFields); Record->push_back(Data.HasBasesWithNonStaticDataMembers); a5885 1 Record->push_back(Data.HasTrivialSpecialMembersForCall); a5886 1 Record->push_back(Data.DeclaredNonTrivialSpecialMembersForCall); d5890 1 d5924 1 a5924 1 // Data.Definition is the owning decl, no need to write it. d5926 1 a5926 1 d6139 1 a6139 2 const FunctionDecl *Delete, Expr *ThisArg) { a6158 9 void ASTWriter::VariableDefinitionInstantiated(const VarDecl *D) { if (Chain && Chain->isProcessingUpdateRecords()) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_VAR_DEFINITION)); } d6168 1 a6168 1 void ASTWriter::InstantiationRequested(const ValueDecl *D) { d6176 3 a6178 6 SourceLocation POI; if (auto *VD = dyn_cast(D)) POI = VD->getPointOfInstantiation(); else POI = cast(D)->getPointOfInstantiation(); DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_POINT_OF_INSTANTIATION, POI)); d6206 1 a6206 1 @ 1.1.1.14 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- ASTWriter.cpp - AST File Writer ------------------------------------===// a19 1 #include "clang/AST/Attr.h" a20 1 #include "clang/AST/DeclBase.h" a23 1 #include "clang/AST/DeclObjC.h" a24 1 #include "clang/AST/DeclarationName.h" a32 1 #include "clang/Basic/Diagnostic.h" a35 1 #include "clang/Basic/IdentifierTable.h" a36 1 #include "clang/Basic/Lambda.h" a40 2 #include "clang/Basic/OpenCLOptions.h" #include "clang/Basic/SourceLocation.h" a42 1 #include "clang/Basic/Specifiers.h" d46 1 a64 3 #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" d66 1 a67 1 #include "llvm/ADT/PointerIntPair.h" a68 1 #include "llvm/ADT/ScopeExit.h" d71 1 a71 3 #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" a75 2 #include "llvm/Support/DJB.h" #include "llvm/Support/Endian.h" d82 1 a83 1 #include "llvm/Support/VersionTuple.h" a89 1 #include d92 1 a92 2 #include #include a94 1 #include d122 4 a125 5 /// Type code that corresponds to the record generated. TypeCode Code = static_cast(0); /// Abbreviation to use for the record, if any. unsigned AbbrevToUse = 0; d129 1 a129 1 : Writer(Writer), Record(Writer, Record) {} d163 1 a163 1 } // namespace clang a258 1 Record.push_back(C.getNoCfCheck()); d276 1 a276 1 } else if (isComputedNoexcept(T->getExceptionSpecType())) { a435 17 void ASTTypeWriter::VisitDependentVectorType(const DependentVectorType *T) { Record.AddTypeRef(T->getElementType()); Record.AddStmt(const_cast(T->getSizeExpr())); Record.AddSourceLocation(T->getAttributeLoc()); Record.push_back(T->getVectorKind()); Code = TYPE_DEPENDENT_SIZED_VECTOR; } void ASTTypeWriter::VisitDependentAddressSpaceType( const DependentAddressSpaceType *T) { Record.AddTypeRef(T->getPointeeType()); Record.AddStmt(T->getAddrSpaceExpr()); Record.AddSourceLocation(T->getAttributeLoc()); Code = TYPE_DEPENDENT_ADDRESS_SPACE; } a484 1 Record.AddDeclRef(T->getOwnedTagDecl()); d544 2 a545 1 TypeLocWriter(ASTRecordWriter &Record) : Record(Record) {} d556 1 a556 1 } // namespace a629 9 void TypeLocWriter::VisitDependentAddressSpaceTypeLoc( DependentAddressSpaceTypeLoc TL) { Record.AddSourceLocation(TL.getAttrNameLoc()); SourceRange range = TL.getAttrOperandParensRange(); Record.AddSourceLocation(range.getBegin()); Record.AddSourceLocation(range.getEnd()); Record.AddStmt(TL.getAttrExprOperand()); } a638 5 void TypeLocWriter::VisitDependentVectorTypeLoc( DependentVectorTypeLoc TL) { Record.AddSourceLocation(TL.getNameLoc()); } a651 1 a654 1 a657 1 a660 1 a663 1 a671 1 a843 1 Abv->Add(BitCodeAbbrevOp(0)); // NoCfCheck a1063 1 RECORD(PPD_SKIPPED_RANGES); a1132 1 RECORD(SUBMODULE_EXPORT_AS); d1252 1 a1252 1 d1275 1 a1275 1 /// Prepares a path for being written to an AST file by converting it d1285 1 a1285 1 /// Adjusts the given filename to only write out the portion of the d1395 1 a1395 1 /// Write the control block. a1399 1 d1402 1 a1402 1 a1411 1 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PCHHasObjectFile d1418 4 a1421 10 RecordData::value_type Record[] = { METADATA, VERSION_MAJOR, VERSION_MINOR, CLANG_VERSION_MAJOR, CLANG_VERSION_MINOR, !isysroot.empty(), IncludeTimestamps, Context.getLangOpts().BuildingPCHWithObjectFile, ASTHasCompilerErrors}; a1507 1 AddString(M.ModuleName, Record); d1689 8 a1696 8 /// An input file. struct InputFileEntry { const FileEntry *File; bool IsSystemFile; bool IsTransient; bool BufferOverridden; bool IsTopLevelModuleMap; }; d1698 1 a1698 1 } // namespace a1703 1 d1798 1 a1798 1 /// Create an abbreviation for the SLocEntry that refers to a d1817 1 a1817 1 /// Create an abbreviation for the SLocEntry that refers to a d1832 1 a1832 1 /// Create an abbreviation for the SLocEntry that refers to a d1847 1 a1847 1 /// Create an abbreviation for the SLocEntry that refers to a macro a1857 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is token range d1867 1 a1867 1 d1871 1 a1871 1 d1880 1 a1880 1 using key_type_ref = const key_type &; d1884 1 a1884 1 d1890 1 a1890 4 using data_type_ref = const data_type &; using hash_value_type = unsigned; using offset_type = unsigned; d1892 3 d1901 2 a1902 2 std::pair d1905 1 a1905 2 endian::Writer LE(Out, little); d1920 1 a1920 2 endian::Writer LE(Out, little); d1931 1 a1931 2 endian::Writer LE(Out, little); d1933 1 a1933 1 d1940 1 a1940 1 d1953 1 a1953 1 FrameworkStringData.append(Data.HFI.Framework.begin(), d1956 1 a1956 1 d1980 1 a1980 1 d1985 1 a1985 1 } // namespace d1987 1 a1987 1 /// Write the header search block for the list of files that d2053 1 a2053 1 a2097 1 d2100 1 a2100 1 endian::write(Out, 0, little); d2114 1 a2114 1 d2120 1 a2120 1 d2129 1 a2129 1 using RecordDataType = ASTWriter::RecordData::value_type; d2150 1 a2150 1 /// Writes the block containing the serialized form of the d2220 1 a2220 1 d2229 1 a2229 1 d2231 1 a2231 1 a2269 1 Record.push_back(Expansion.isExpansionTokenRange()); a2314 1 FilenameMap[-1] = -1; // For unspecified filenames. d2320 1 a2320 1 FilenameMap.size() - 1)).second) d2371 1 a2371 1 /// Writes the block containing the serialized form of the d2373 1 a2389 11 auto SkipInfo = PP.getPreambleSkipInfo(); if (SkipInfo.hasValue()) { Record.push_back(true); AddSourceLocation(SkipInfo->HashTokenLoc, Record); AddSourceLocation(SkipInfo->IfTokenLoc, Record); Record.push_back(SkipInfo->FoundNonSkipPortion); Record.push_back(SkipInfo->FoundElse); AddSourceLocation(SkipInfo->ElseLoc, Record); } else { Record.push_back(false); } d2421 2 a2422 2 llvm::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), llvm::less_ptr()); d2481 1 a2481 1 /// Offsets of each of the macros into the bitstream, indexed by d2581 2 a2582 2 // Set up the abbreviation for d2594 3 a2596 3 unsigned FirstPreprocessorEntityID = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) d2602 1 a2602 1 E != EEnd; d2643 1 a2643 1 a2666 20 // Write the skipped region table for the preprocessing record. ArrayRef SkippedRanges = PPRec.getSkippedRanges(); if (SkippedRanges.size() > 0) { std::vector SerializedSkippedRanges; SerializedSkippedRanges.reserve(SkippedRanges.size()); for (auto const& Range : SkippedRanges) SerializedSkippedRanges.emplace_back(Range); using namespace llvm; auto Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(PPD_SKIPPED_RANGES)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); Record.clear(); Record.push_back(PPD_SKIPPED_RANGES); Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev, Record, bytes(SerializedSkippedRanges)); } d2696 1 a2696 1 /// Compute the number of modules within the given tree (including the d2703 1 a2703 1 d2710 1 a2710 1 a2717 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind a2725 1 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModuleMapIsPriv... a2791 5 Abbrev = std::make_shared(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXPORT_AS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); d2795 2 a2796 1 FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS}; d2798 1 a2798 1 a2817 1 (RecordData::value_type)Mod->Kind, d2825 1 a2825 2 Mod->ConfigMacrosExhaustive, Mod->ModuleMapIsPrivate}; d2873 1 a2873 1 // Emit the imports. d2881 1 a2881 1 // Emit the exports. a2925 6 // Emit the name of the re-exported module, if any. if (!Mod->ExportAsModule.empty()) { RecordData::value_type Record[] = {SUBMODULE_EXPORT_AS}; Stream.EmitRecordWithBlob(ExportAsAbbrev, Record, Mod->ExportAsModule); } d2930 1 a2930 1 d2969 1 a2969 1 d3000 2 a3001 5 SourceLocation Loc = Diag.SourceMgr->getComposedLoc(FileIDAndFile.first, 0); assert(!Loc.isInvalid() && "start loc for valid FileID is invalid"); AddSourceLocation(Loc, Record); d3028 1 a3028 1 /// Write the representation of a type to the AST stream. d3060 1 a3060 1 /// Write the block containing all of the declaration IDs d3064 1 a3064 1 /// bitstream, or 0 if no block was written. d3119 2 a3120 2 llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), llvm::less_first()); a3142 3 auto _ = llvm::make_scope_exit([this] { Stream.ExitBlock(); }); if (!PP->getPreprocessorOpts().WriteCommentListToPCH) return; d3153 1 d3167 2 a3168 2 using key_type = Selector; using key_type_ref = key_type; d3174 1 a3174 1 using data_type_ref = const data_type &; d3176 2 a3177 2 using hash_value_type = unsigned; using offset_type = unsigned; d3179 1 a3179 1 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) {} d3185 1 a3185 1 std::pair d3189 1 a3189 2 endian::Writer LE(Out, little); d3207 1 a3207 2 endian::Writer LE(Out, little); d3223 1 a3223 2 endian::Writer LE(Out, little); d3267 1 a3267 1 } // namespace d3269 1 a3269 1 /// Write ObjC data: selectors and the method pool. a3330 1 d3334 1 a3334 1 endian::write(Out, 0, little); d3372 1 a3372 1 /// Write the selectors referenced in @@selector expression into AST file. a3374 1 d3446 2 a3447 2 /// Determines whether this is an "interesting" identifier that needs a d3463 2 a3464 2 using key_type = IdentifierInfo *; using key_type_ref = key_type; d3466 2 a3467 2 using data_type = IdentID; using data_type_ref = data_type; d3469 2 a3470 2 using hash_value_type = unsigned; using offset_type = unsigned; d3482 1 a3482 1 return llvm::djbHash(II->getName()); d3494 1 a3494 1 std::pair a3511 1 d3513 1 a3513 2 endian::Writer LE(Out, little); d3541 1 a3541 2 endian::Writer LE(Out, little); d3584 1 a3584 1 } // namespace d3586 1 a3586 1 /// Write the identifier table into the AST file. d3591 1 a3591 1 void ASTWriter::WriteIdentifierTable(Preprocessor &PP, d3616 1 a3616 1 llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); a3641 1 d3644 1 a3644 1 endian::write(Out, 0, little); d3697 2 a3698 2 using key_type = DeclarationNameKey; using key_type_ref = key_type; d3701 2 a3702 2 using data_type = std::pair; using data_type_ref = const data_type &; d3704 2 a3705 2 using hash_value_type = unsigned; using offset_type = unsigned; d3707 1 a3707 1 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) {} d3739 2 a3740 2 endian::write(Out, Writer.getChain()->getModuleFileID(F), little); d3747 1 a3747 2 endian::Writer LE(Out, little); d3780 1 a3780 2 endian::Writer LE(Out, little); d3811 1 a3811 2 endian::Writer LE(Out, little); d3819 1 a3819 1 } // namespace d3909 1 a3909 1 llvm::sort(Names.begin(), Names.end()); d4012 1 a4012 1 /// Write the block containing all of the declaration IDs d4046 1 a4046 1 llvm::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); d4102 1 a4102 1 /// Write an UPDATE_VISIBLE block for the given context. d4127 1 a4127 1 /// Write an FP_PRAGMA_OPTIONS block for the given FPOptions. d4133 1 a4133 1 /// Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. d4190 1 a4190 1 d4194 1 a4194 1 d4196 1 a4196 1 d4199 1 a4199 1 d4208 1 a4208 1 d4211 1 a4211 1 d4260 1 a4260 1 /// Write the state of 'pragma clang optimize' at the end of the module. d4268 1 a4268 1 /// Write the state of 'pragma ms_struct' at the end of the module. d4275 1 a4275 1 /// Write the state of 'pragma pointers_to_members' at the end of the d4284 1 a4284 1 /// Write the state of 'pragma pack' at the end of the module. a4297 1 AddSourceLocation(StackEntry.PragmaPushLocation, Record); d4342 1 a4342 1 /// Emit the list of attributes to the specified record. d4351 1 d4417 1 a4417 1 /// Note that the identifier II occurs at the given offset d4427 1 a4427 1 /// Note that the selector Sel occurs at the given offset d4471 1 a4471 1 d4519 1 a4519 1 d4560 1 a4560 1 d4648 7 a4654 9 if (!isModule) { for (const auto &DeleteExprsInfo : SemaRef.getMismatchingDeleteExpressions()) { AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size()); for (const auto &DeleteLoc : DeleteExprsInfo.second) { AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze); DeleteExprsToAnalyze.push_back(DeleteLoc.second); } d4681 1 a4681 1 d4703 1 a4703 1 d4742 1 a4742 1 llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); d4781 1 a4781 2 // *(module-kind:i8 // module-name-len:i16 module-name:len*i8 d4791 1 a4791 4 // // module-kind is the ModuleKind enum value. If it is MK_PrebuiltModule or // MK_ExplicitModule, then the module-name is the module name. Otherwise, // it is the module file name. d4801 4 a4804 9 endian::Writer LE(Out, little); LE.write(static_cast(M.Kind)); StringRef Name = M.Kind == MK_PrebuiltModule || M.Kind == MK_ExplicitModule ? M.ModuleName : M.FileName; LE.write(Name.size()); Out.write(Name.data(), Name.size()); d4877 1 a4877 1 // If we're emitting a module, write out the submodule information. d4927 1 a4927 1 d4970 1 a4970 1 llvm::sort(Imports.begin(), Imports.end(), Cmp); d5042 2 a5043 2 case UPD_CXX_POINT_OF_INSTANTIATION: // FIXME: Do we need to also save the template specialization kind here? a5044 6 break; case UPD_CXX_ADDED_VAR_DEFINITION: { const VarDecl *VD = cast(D); Record.push_back(VD->isInline()); Record.push_back(VD->isInlineSpecified()); a5067 2 Record.push_back(RD->isParamDestroyedInCallee()); Record.push_back(RD->getArgPassingRestrictions()); a5111 1 Record.AddStmt(cast(D)->getOperatorDeleteThisArg()); d5223 1 a5223 1 a5305 1 AddTypeRef(TInfo->getType()); d5310 2 d5367 1 a5367 1 d5372 1 a5372 1 d5416 1 a5416 3 // TemplateTemplateParmDecls that are part of an alias template, should not // have TU as lexical context. if (isa(D) || isa(D)) a5633 1 AddTypeRef(NNS.getTypeLoc().getType()); d5692 1 a5692 1 d5755 1 a5755 1 /// Emit a template argument list. d5792 1 a5792 1 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() d5865 1 a5865 3 Record->push_back(Data.IsCXX11StandardLayout); Record->push_back(Data.HasBasesWithFields); Record->push_back(Data.HasBasesWithNonStaticDataMembers); a5885 1 Record->push_back(Data.HasTrivialSpecialMembersForCall); a5886 1 Record->push_back(Data.DeclaredNonTrivialSpecialMembersForCall); d5890 1 d5924 1 a5924 1 // Data.Definition is the owning decl, no need to write it. d5926 1 a5926 1 d6139 1 a6139 2 const FunctionDecl *Delete, Expr *ThisArg) { a6158 9 void ASTWriter::VariableDefinitionInstantiated(const VarDecl *D) { if (Chain && Chain->isProcessingUpdateRecords()) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_VAR_DEFINITION)); } d6168 1 a6168 1 void ASTWriter::InstantiationRequested(const ValueDecl *D) { d6176 3 a6178 6 SourceLocation POI; if (auto *VD = dyn_cast(D)) POI = VD->getPointOfInstantiation(); else POI = cast(D)->getPointOfInstantiation(); DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_POINT_OF_INSTANTIATION, POI)); d6206 1 a6206 1 @ 1.1.1.15 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file ASTWriter.cpp was added on branch tls-maxphys on 2014-08-19 23:47:31 +0000 @ text @d1 5767 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 5767 //===--- ASTWriter.cpp - AST File Writer ----------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the ASTWriter class, which writes AST files. // //===----------------------------------------------------------------------===// #include "clang/Serialization/ASTWriter.h" #include "ASTCommon.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclContextInternals.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclLookups.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLocVisitor.h" #include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/FileSystemStatCache.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManagerInternals.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Basic/Version.h" #include "clang/Basic/VersionTuple.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/PreprocessingRecord.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/PreprocessorOptions.h" #include "clang/Sema/IdentifierResolver.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/Hashing.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Support/EndianStream.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/OnDiskHashTable.h" #include "llvm/Support/Path.h" #include #include #include #include using namespace clang; using namespace clang::serialization; template static StringRef data(const std::vector &v) { if (v.empty()) return StringRef(); return StringRef(reinterpret_cast(&v[0]), sizeof(T) * v.size()); } template static StringRef data(const SmallVectorImpl &v) { return StringRef(reinterpret_cast(v.data()), sizeof(T) * v.size()); } //===----------------------------------------------------------------------===// // Type serialization //===----------------------------------------------------------------------===// namespace { class ASTTypeWriter { ASTWriter &Writer; ASTWriter::RecordDataImpl &Record; public: /// \brief Type code that corresponds to the record generated. TypeCode Code; /// \brief Abbreviation to use for the record, if any. unsigned AbbrevToUse; ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { } void VisitArrayType(const ArrayType *T); void VisitFunctionType(const FunctionType *T); void VisitTagType(const TagType *T); #define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" }; } void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { llvm_unreachable("Built-in types are never serialized"); } void ASTTypeWriter::VisitComplexType(const ComplexType *T) { Writer.AddTypeRef(T->getElementType(), Record); Code = TYPE_COMPLEX; } void ASTTypeWriter::VisitPointerType(const PointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_POINTER; } void ASTTypeWriter::VisitDecayedType(const DecayedType *T) { Writer.AddTypeRef(T->getOriginalType(), Record); Code = TYPE_DECAYED; } void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) { Writer.AddTypeRef(T->getOriginalType(), Record); Writer.AddTypeRef(T->getAdjustedType(), Record); Code = TYPE_ADJUSTED; } void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_BLOCK_POINTER; } void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); Record.push_back(T->isSpelledAsLValue()); Code = TYPE_LVALUE_REFERENCE; } void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); Code = TYPE_RVALUE_REFERENCE; } void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Writer.AddTypeRef(QualType(T->getClass(), 0), Record); Code = TYPE_MEMBER_POINTER; } void ASTTypeWriter::VisitArrayType(const ArrayType *T) { Writer.AddTypeRef(T->getElementType(), Record); Record.push_back(T->getSizeModifier()); // FIXME: stable values Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values } void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { VisitArrayType(T); Writer.AddAPInt(T->getSize(), Record); Code = TYPE_CONSTANT_ARRAY; } void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { VisitArrayType(T); Code = TYPE_INCOMPLETE_ARRAY; } void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { VisitArrayType(T); Writer.AddSourceLocation(T->getLBracketLoc(), Record); Writer.AddSourceLocation(T->getRBracketLoc(), Record); Writer.AddStmt(T->getSizeExpr()); Code = TYPE_VARIABLE_ARRAY; } void ASTTypeWriter::VisitVectorType(const VectorType *T) { Writer.AddTypeRef(T->getElementType(), Record); Record.push_back(T->getNumElements()); Record.push_back(T->getVectorKind()); Code = TYPE_VECTOR; } void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { VisitVectorType(T); Code = TYPE_EXT_VECTOR; } void ASTTypeWriter::VisitFunctionType(const FunctionType *T) { Writer.AddTypeRef(T->getReturnType(), Record); FunctionType::ExtInfo C = T->getExtInfo(); Record.push_back(C.getNoReturn()); Record.push_back(C.getHasRegParm()); Record.push_back(C.getRegParm()); // FIXME: need to stabilize encoding of calling convention... Record.push_back(C.getCC()); Record.push_back(C.getProducesResult()); if (C.getHasRegParm() || C.getRegParm() || C.getProducesResult()) AbbrevToUse = 0; } void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { VisitFunctionType(T); Code = TYPE_FUNCTION_NO_PROTO; } static void addExceptionSpec(ASTWriter &Writer, const FunctionProtoType *T, ASTWriter::RecordDataImpl &Record) { Record.push_back(T->getExceptionSpecType()); if (T->getExceptionSpecType() == EST_Dynamic) { Record.push_back(T->getNumExceptions()); for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) Writer.AddTypeRef(T->getExceptionType(I), Record); } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) { Writer.AddStmt(T->getNoexceptExpr()); } else if (T->getExceptionSpecType() == EST_Uninstantiated) { Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record); } else if (T->getExceptionSpecType() == EST_Unevaluated) { Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); } } void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { VisitFunctionType(T); Record.push_back(T->isVariadic()); Record.push_back(T->hasTrailingReturn()); Record.push_back(T->getTypeQuals()); Record.push_back(static_cast(T->getRefQualifier())); addExceptionSpec(Writer, T, Record); Record.push_back(T->getNumParams()); for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Writer.AddTypeRef(T->getParamType(I), Record); if (T->isVariadic() || T->hasTrailingReturn() || T->getTypeQuals() || T->getRefQualifier() || T->getExceptionSpecType() != EST_None) AbbrevToUse = 0; Code = TYPE_FUNCTION_PROTO; } void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { Writer.AddDeclRef(T->getDecl(), Record); Code = TYPE_UNRESOLVED_USING; } void ASTTypeWriter::VisitTypedefType(const TypedefType *T) { Writer.AddDeclRef(T->getDecl(), Record); assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record); Code = TYPE_TYPEDEF; } void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { Writer.AddStmt(T->getUnderlyingExpr()); Code = TYPE_TYPEOF_EXPR; } void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { Writer.AddTypeRef(T->getUnderlyingType(), Record); Code = TYPE_TYPEOF; } void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { Writer.AddTypeRef(T->getUnderlyingType(), Record); Writer.AddStmt(T->getUnderlyingExpr()); Code = TYPE_DECLTYPE; } void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) { Writer.AddTypeRef(T->getBaseType(), Record); Writer.AddTypeRef(T->getUnderlyingType(), Record); Record.push_back(T->getUTTKind()); Code = TYPE_UNARY_TRANSFORM; } void ASTTypeWriter::VisitAutoType(const AutoType *T) { Writer.AddTypeRef(T->getDeducedType(), Record); Record.push_back(T->isDecltypeAuto()); if (T->getDeducedType().isNull()) Record.push_back(T->isDependentType()); Code = TYPE_AUTO; } void ASTTypeWriter::VisitTagType(const TagType *T) { Record.push_back(T->isDependentType()); Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); assert(!T->isBeingDefined() && "Cannot serialize in the middle of a type definition"); } void ASTTypeWriter::VisitRecordType(const RecordType *T) { VisitTagType(T); Code = TYPE_RECORD; } void ASTTypeWriter::VisitEnumType(const EnumType *T) { VisitTagType(T); Code = TYPE_ENUM; } void ASTTypeWriter::VisitAttributedType(const AttributedType *T) { Writer.AddTypeRef(T->getModifiedType(), Record); Writer.AddTypeRef(T->getEquivalentType(), Record); Record.push_back(T->getAttrKind()); Code = TYPE_ATTRIBUTED; } void ASTTypeWriter::VisitSubstTemplateTypeParmType( const SubstTemplateTypeParmType *T) { Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); Writer.AddTypeRef(T->getReplacementType(), Record); Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; } void ASTTypeWriter::VisitSubstTemplateTypeParmPackType( const SubstTemplateTypeParmPackType *T) { Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); Writer.AddTemplateArgument(T->getArgumentPack(), Record); Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK; } void ASTTypeWriter::VisitTemplateSpecializationType( const TemplateSpecializationType *T) { Record.push_back(T->isDependentType()); Writer.AddTemplateName(T->getTemplateName(), Record); Record.push_back(T->getNumArgs()); for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end(); ArgI != ArgE; ++ArgI) Writer.AddTemplateArgument(*ArgI, Record); Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() : T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal(), Record); Code = TYPE_TEMPLATE_SPECIALIZATION; } void ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { VisitArrayType(T); Writer.AddStmt(T->getSizeExpr()); Writer.AddSourceRange(T->getBracketsRange(), Record); Code = TYPE_DEPENDENT_SIZED_ARRAY; } void ASTTypeWriter::VisitDependentSizedExtVectorType( const DependentSizedExtVectorType *T) { // FIXME: Serialize this type (C++ only) llvm_unreachable("Cannot serialize dependent sized extended vector types"); } void ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { Record.push_back(T->getDepth()); Record.push_back(T->getIndex()); Record.push_back(T->isParameterPack()); Writer.AddDeclRef(T->getDecl(), Record); Code = TYPE_TEMPLATE_TYPE_PARM; } void ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddIdentifierRef(T->getIdentifier(), Record); Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal(), Record); Code = TYPE_DEPENDENT_NAME; } void ASTTypeWriter::VisitDependentTemplateSpecializationType( const DependentTemplateSpecializationType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddIdentifierRef(T->getIdentifier(), Record); Record.push_back(T->getNumArgs()); for (DependentTemplateSpecializationType::iterator I = T->begin(), E = T->end(); I != E; ++I) Writer.AddTemplateArgument(*I, Record); Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; } void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { Writer.AddTypeRef(T->getPattern(), Record); if (Optional NumExpansions = T->getNumExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); Code = TYPE_PACK_EXPANSION; } void ASTTypeWriter::VisitParenType(const ParenType *T) { Writer.AddTypeRef(T->getInnerType(), Record); Code = TYPE_PAREN; } void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddTypeRef(T->getNamedType(), Record); Code = TYPE_ELABORATED; } void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); Code = TYPE_INJECTED_CLASS_NAME; } void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Code = TYPE_OBJC_INTERFACE; } void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { Writer.AddTypeRef(T->getBaseType(), Record); Record.push_back(T->getNumProtocols()); for (const auto *I : T->quals()) Writer.AddDeclRef(I, Record); Code = TYPE_OBJC_OBJECT; } void ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_OBJC_OBJECT_POINTER; } void ASTTypeWriter::VisitAtomicType(const AtomicType *T) { Writer.AddTypeRef(T->getValueType(), Record); Code = TYPE_ATOMIC; } namespace { class TypeLocWriter : public TypeLocVisitor { ASTWriter &Writer; ASTWriter::RecordDataImpl &Record; public: TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) : Writer(Writer), Record(Record) { } #define ABSTRACT_TYPELOC(CLASS, PARENT) #define TYPELOC(CLASS, PARENT) \ void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); #include "clang/AST/TypeLocNodes.def" void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); }; } void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { Writer.AddSourceLocation(TL.getBuiltinLoc(), Record); if (TL.needsExtraLocalData()) { Record.push_back(TL.getWrittenTypeSpec()); Record.push_back(TL.getWrittenSignSpec()); Record.push_back(TL.getWrittenWidthSpec()); Record.push_back(TL.hasModeAttr()); } } void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); } void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getCaretLoc(), Record); } void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { Writer.AddSourceLocation(TL.getAmpLoc(), Record); } void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record); } void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record); } void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { Writer.AddSourceLocation(TL.getLBracketLoc(), Record); Writer.AddSourceLocation(TL.getRBracketLoc(), Record); Record.push_back(TL.getSizeExpr() ? 1 : 0); if (TL.getSizeExpr()) Writer.AddStmt(TL.getSizeExpr()); } void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitDependentSizedArrayTypeLoc( DependentSizedArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( DependentSizedExtVectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record); for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) Writer.AddDeclRef(TL.getParam(i), Record); } void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { VisitFunctionTypeLoc(TL); } void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { VisitFunctionTypeLoc(TL); } void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { Writer.AddSourceLocation(TL.getTypeofLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { Writer.AddSourceLocation(TL.getTypeofLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); } void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { Writer.AddSourceLocation(TL.getKWLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); } void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { Writer.AddSourceLocation(TL.getAttrNameLoc(), Record); if (TL.hasAttrOperand()) { SourceRange range = TL.getAttrOperandParensRange(); Writer.AddSourceLocation(range.getBegin(), Record); Writer.AddSourceLocation(range.getEnd(), Record); } if (TL.hasAttrExprOperand()) { Expr *operand = TL.getAttrExprOperand(); Record.push_back(operand ? 1 : 0); if (operand) Writer.AddStmt(operand); } else if (TL.hasAttrEnumOperand()) { Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record); } } void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( SubstTemplateTypeParmTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( SubstTemplateTypeParmPackTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTemplateSpecializationTypeLoc( TemplateSpecializationTypeLoc TL) { Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), TL.getArgLoc(i).getLocInfo(), Record); } void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); } void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( DependentTemplateSpecializationTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), TL.getArgLoc(I).getLocInfo(), Record); } void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { Writer.AddSourceLocation(TL.getEllipsisLoc(), Record); } void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { Record.push_back(TL.hasBaseTypeAsWritten()); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) Writer.AddSourceLocation(TL.getProtocolLoc(i), Record); } void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); } void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) { Writer.AddSourceLocation(TL.getKWLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void ASTWriter::WriteTypeAbbrevs() { using namespace llvm; BitCodeAbbrev *Abv; // Abbreviation for TYPE_EXT_QUAL Abv = new BitCodeAbbrev(); Abv->Add(BitCodeAbbrevOp(serialization::TYPE_EXT_QUAL)); Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3)); // Quals TypeExtQualAbbrev = Stream.EmitAbbrev(Abv); // Abbreviation for TYPE_FUNCTION_PROTO Abv = new BitCodeAbbrev(); Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO)); // FunctionType Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ReturnType Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn Abv->Add(BitCodeAbbrevOp(0)); // HasRegParm Abv->Add(BitCodeAbbrevOp(0)); // RegParm Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC Abv->Add(BitCodeAbbrevOp(0)); // ProducesResult // FunctionProtoType Abv->Add(BitCodeAbbrevOp(0)); // IsVariadic Abv->Add(BitCodeAbbrevOp(0)); // HasTrailingReturn Abv->Add(BitCodeAbbrevOp(0)); // TypeQuals Abv->Add(BitCodeAbbrevOp(0)); // RefQualifier Abv->Add(BitCodeAbbrevOp(EST_None)); // ExceptionSpec Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumParams Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Params TypeFunctionProtoAbbrev = Stream.EmitAbbrev(Abv); } //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// static void EmitBlockID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { Record.clear(); Record.push_back(ID); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); // Emit the block name if present. if (!Name || Name[0] == 0) return; Record.clear(); while (*Name) Record.push_back(*Name++); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); } static void EmitRecordID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { Record.clear(); Record.push_back(ID); while (*Name) Record.push_back(*Name++); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); } static void AddStmtsExprs(llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { #define RECORD(X) EmitRecordID(X, #X, Stream, Record) RECORD(STMT_STOP); RECORD(STMT_NULL_PTR); RECORD(STMT_REF_PTR); RECORD(STMT_NULL); RECORD(STMT_COMPOUND); RECORD(STMT_CASE); RECORD(STMT_DEFAULT); RECORD(STMT_LABEL); RECORD(STMT_ATTRIBUTED); RECORD(STMT_IF); RECORD(STMT_SWITCH); RECORD(STMT_WHILE); RECORD(STMT_DO); RECORD(STMT_FOR); RECORD(STMT_GOTO); RECORD(STMT_INDIRECT_GOTO); RECORD(STMT_CONTINUE); RECORD(STMT_BREAK); RECORD(STMT_RETURN); RECORD(STMT_DECL); RECORD(STMT_GCCASM); RECORD(STMT_MSASM); RECORD(EXPR_PREDEFINED); RECORD(EXPR_DECL_REF); RECORD(EXPR_INTEGER_LITERAL); RECORD(EXPR_FLOATING_LITERAL); RECORD(EXPR_IMAGINARY_LITERAL); RECORD(EXPR_STRING_LITERAL); RECORD(EXPR_CHARACTER_LITERAL); RECORD(EXPR_PAREN); RECORD(EXPR_PAREN_LIST); RECORD(EXPR_UNARY_OPERATOR); RECORD(EXPR_SIZEOF_ALIGN_OF); RECORD(EXPR_ARRAY_SUBSCRIPT); RECORD(EXPR_CALL); RECORD(EXPR_MEMBER); RECORD(EXPR_BINARY_OPERATOR); RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); RECORD(EXPR_CONDITIONAL_OPERATOR); RECORD(EXPR_IMPLICIT_CAST); RECORD(EXPR_CSTYLE_CAST); RECORD(EXPR_COMPOUND_LITERAL); RECORD(EXPR_EXT_VECTOR_ELEMENT); RECORD(EXPR_INIT_LIST); RECORD(EXPR_DESIGNATED_INIT); RECORD(EXPR_IMPLICIT_VALUE_INIT); RECORD(EXPR_VA_ARG); RECORD(EXPR_ADDR_LABEL); RECORD(EXPR_STMT); RECORD(EXPR_CHOOSE); RECORD(EXPR_GNU_NULL); RECORD(EXPR_SHUFFLE_VECTOR); RECORD(EXPR_BLOCK); RECORD(EXPR_GENERIC_SELECTION); RECORD(EXPR_OBJC_STRING_LITERAL); RECORD(EXPR_OBJC_BOXED_EXPRESSION); RECORD(EXPR_OBJC_ARRAY_LITERAL); RECORD(EXPR_OBJC_DICTIONARY_LITERAL); RECORD(EXPR_OBJC_ENCODE); RECORD(EXPR_OBJC_SELECTOR_EXPR); RECORD(EXPR_OBJC_PROTOCOL_EXPR); RECORD(EXPR_OBJC_IVAR_REF_EXPR); RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); RECORD(EXPR_OBJC_KVC_REF_EXPR); RECORD(EXPR_OBJC_MESSAGE_EXPR); RECORD(STMT_OBJC_FOR_COLLECTION); RECORD(STMT_OBJC_CATCH); RECORD(STMT_OBJC_FINALLY); RECORD(STMT_OBJC_AT_TRY); RECORD(STMT_OBJC_AT_SYNCHRONIZED); RECORD(STMT_OBJC_AT_THROW); RECORD(EXPR_OBJC_BOOL_LITERAL); RECORD(STMT_CXX_CATCH); RECORD(STMT_CXX_TRY); RECORD(STMT_CXX_FOR_RANGE); RECORD(EXPR_CXX_OPERATOR_CALL); RECORD(EXPR_CXX_MEMBER_CALL); RECORD(EXPR_CXX_CONSTRUCT); RECORD(EXPR_CXX_TEMPORARY_OBJECT); RECORD(EXPR_CXX_STATIC_CAST); RECORD(EXPR_CXX_DYNAMIC_CAST); RECORD(EXPR_CXX_REINTERPRET_CAST); RECORD(EXPR_CXX_CONST_CAST); RECORD(EXPR_CXX_FUNCTIONAL_CAST); RECORD(EXPR_USER_DEFINED_LITERAL); RECORD(EXPR_CXX_STD_INITIALIZER_LIST); RECORD(EXPR_CXX_BOOL_LITERAL); RECORD(EXPR_CXX_NULL_PTR_LITERAL); RECORD(EXPR_CXX_TYPEID_EXPR); RECORD(EXPR_CXX_TYPEID_TYPE); RECORD(EXPR_CXX_THIS); RECORD(EXPR_CXX_THROW); RECORD(EXPR_CXX_DEFAULT_ARG); RECORD(EXPR_CXX_DEFAULT_INIT); RECORD(EXPR_CXX_BIND_TEMPORARY); RECORD(EXPR_CXX_SCALAR_VALUE_INIT); RECORD(EXPR_CXX_NEW); RECORD(EXPR_CXX_DELETE); RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR); RECORD(EXPR_EXPR_WITH_CLEANUPS); RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER); RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF); RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT); RECORD(EXPR_CXX_UNRESOLVED_MEMBER); RECORD(EXPR_CXX_UNRESOLVED_LOOKUP); RECORD(EXPR_CXX_EXPRESSION_TRAIT); RECORD(EXPR_CXX_NOEXCEPT); RECORD(EXPR_OPAQUE_VALUE); RECORD(EXPR_BINARY_CONDITIONAL_OPERATOR); RECORD(EXPR_TYPE_TRAIT); RECORD(EXPR_ARRAY_TYPE_TRAIT); RECORD(EXPR_PACK_EXPANSION); RECORD(EXPR_SIZEOF_PACK); RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM); RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK); RECORD(EXPR_FUNCTION_PARM_PACK); RECORD(EXPR_MATERIALIZE_TEMPORARY); RECORD(EXPR_CUDA_KERNEL_CALL); RECORD(EXPR_CXX_UUIDOF_EXPR); RECORD(EXPR_CXX_UUIDOF_TYPE); RECORD(EXPR_LAMBDA); #undef RECORD } void ASTWriter::WriteBlockInfoBlock() { RecordData Record; Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) #define RECORD(X) EmitRecordID(X, #X, Stream, Record) // Control Block. BLOCK(CONTROL_BLOCK); RECORD(METADATA); RECORD(MODULE_NAME); RECORD(MODULE_MAP_FILE); RECORD(IMPORTS); RECORD(LANGUAGE_OPTIONS); RECORD(TARGET_OPTIONS); RECORD(ORIGINAL_FILE); RECORD(ORIGINAL_PCH_DIR); RECORD(ORIGINAL_FILE_ID); RECORD(INPUT_FILE_OFFSETS); RECORD(DIAGNOSTIC_OPTIONS); RECORD(FILE_SYSTEM_OPTIONS); RECORD(HEADER_SEARCH_OPTIONS); RECORD(PREPROCESSOR_OPTIONS); BLOCK(INPUT_FILES_BLOCK); RECORD(INPUT_FILE); // AST Top-Level Block. BLOCK(AST_BLOCK); RECORD(TYPE_OFFSET); RECORD(DECL_OFFSET); RECORD(IDENTIFIER_OFFSET); RECORD(IDENTIFIER_TABLE); RECORD(EAGERLY_DESERIALIZED_DECLS); RECORD(SPECIAL_TYPES); RECORD(STATISTICS); RECORD(TENTATIVE_DEFINITIONS); RECORD(UNUSED_FILESCOPED_DECLS); RECORD(LOCALLY_SCOPED_EXTERN_C_DECLS); RECORD(SELECTOR_OFFSETS); RECORD(METHOD_POOL); RECORD(PP_COUNTER_VALUE); RECORD(SOURCE_LOCATION_OFFSETS); RECORD(SOURCE_LOCATION_PRELOADS); RECORD(EXT_VECTOR_DECLS); RECORD(PPD_ENTITIES_OFFSETS); RECORD(REFERENCED_SELECTOR_POOL); RECORD(TU_UPDATE_LEXICAL); RECORD(LOCAL_REDECLARATIONS_MAP); RECORD(SEMA_DECL_REFS); RECORD(WEAK_UNDECLARED_IDENTIFIERS); RECORD(PENDING_IMPLICIT_INSTANTIATIONS); RECORD(DECL_REPLACEMENTS); RECORD(UPDATE_VISIBLE); RECORD(DECL_UPDATE_OFFSETS); RECORD(DECL_UPDATES); RECORD(CXX_BASE_SPECIFIER_OFFSETS); RECORD(DIAG_PRAGMA_MAPPINGS); RECORD(CUDA_SPECIAL_DECL_REFS); RECORD(HEADER_SEARCH_TABLE); RECORD(FP_PRAGMA_OPTIONS); RECORD(OPENCL_EXTENSIONS); RECORD(DELEGATING_CTORS); RECORD(KNOWN_NAMESPACES); RECORD(UNDEFINED_BUT_USED); RECORD(MODULE_OFFSET_MAP); RECORD(SOURCE_MANAGER_LINE_TABLE); RECORD(OBJC_CATEGORIES_MAP); RECORD(FILE_SORTED_DECLS); RECORD(IMPORTED_MODULES); RECORD(MERGED_DECLARATIONS); RECORD(LOCAL_REDECLARATIONS); RECORD(OBJC_CATEGORIES); RECORD(MACRO_OFFSET); RECORD(MACRO_TABLE); RECORD(LATE_PARSED_TEMPLATE); RECORD(OPTIMIZE_PRAGMA_OPTIONS); // SourceManager Block. BLOCK(SOURCE_MANAGER_BLOCK); RECORD(SM_SLOC_FILE_ENTRY); RECORD(SM_SLOC_BUFFER_ENTRY); RECORD(SM_SLOC_BUFFER_BLOB); RECORD(SM_SLOC_EXPANSION_ENTRY); // Preprocessor Block. BLOCK(PREPROCESSOR_BLOCK); RECORD(PP_MACRO_OBJECT_LIKE); RECORD(PP_MACRO_FUNCTION_LIKE); RECORD(PP_TOKEN); // Decls and Types block. BLOCK(DECLTYPES_BLOCK); RECORD(TYPE_EXT_QUAL); RECORD(TYPE_COMPLEX); RECORD(TYPE_POINTER); RECORD(TYPE_BLOCK_POINTER); RECORD(TYPE_LVALUE_REFERENCE); RECORD(TYPE_RVALUE_REFERENCE); RECORD(TYPE_MEMBER_POINTER); RECORD(TYPE_CONSTANT_ARRAY); RECORD(TYPE_INCOMPLETE_ARRAY); RECORD(TYPE_VARIABLE_ARRAY); RECORD(TYPE_VECTOR); RECORD(TYPE_EXT_VECTOR); RECORD(TYPE_FUNCTION_NO_PROTO); RECORD(TYPE_FUNCTION_PROTO); RECORD(TYPE_TYPEDEF); RECORD(TYPE_TYPEOF_EXPR); RECORD(TYPE_TYPEOF); RECORD(TYPE_RECORD); RECORD(TYPE_ENUM); RECORD(TYPE_OBJC_INTERFACE); RECORD(TYPE_OBJC_OBJECT_POINTER); RECORD(TYPE_DECLTYPE); RECORD(TYPE_ELABORATED); RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM); RECORD(TYPE_UNRESOLVED_USING); RECORD(TYPE_INJECTED_CLASS_NAME); RECORD(TYPE_OBJC_OBJECT); RECORD(TYPE_TEMPLATE_TYPE_PARM); RECORD(TYPE_TEMPLATE_SPECIALIZATION); RECORD(TYPE_DEPENDENT_NAME); RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION); RECORD(TYPE_DEPENDENT_SIZED_ARRAY); RECORD(TYPE_PAREN); RECORD(TYPE_PACK_EXPANSION); RECORD(TYPE_ATTRIBUTED); RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK); RECORD(TYPE_AUTO); RECORD(TYPE_UNARY_TRANSFORM); RECORD(TYPE_ATOMIC); RECORD(TYPE_DECAYED); RECORD(TYPE_ADJUSTED); RECORD(DECL_TYPEDEF); RECORD(DECL_TYPEALIAS); RECORD(DECL_ENUM); RECORD(DECL_RECORD); RECORD(DECL_ENUM_CONSTANT); RECORD(DECL_FUNCTION); RECORD(DECL_OBJC_METHOD); RECORD(DECL_OBJC_INTERFACE); RECORD(DECL_OBJC_PROTOCOL); RECORD(DECL_OBJC_IVAR); RECORD(DECL_OBJC_AT_DEFS_FIELD); RECORD(DECL_OBJC_CATEGORY); RECORD(DECL_OBJC_CATEGORY_IMPL); RECORD(DECL_OBJC_IMPLEMENTATION); RECORD(DECL_OBJC_COMPATIBLE_ALIAS); RECORD(DECL_OBJC_PROPERTY); RECORD(DECL_OBJC_PROPERTY_IMPL); RECORD(DECL_FIELD); RECORD(DECL_MS_PROPERTY); RECORD(DECL_VAR); RECORD(DECL_IMPLICIT_PARAM); RECORD(DECL_PARM_VAR); RECORD(DECL_FILE_SCOPE_ASM); RECORD(DECL_BLOCK); RECORD(DECL_CONTEXT_LEXICAL); RECORD(DECL_CONTEXT_VISIBLE); RECORD(DECL_NAMESPACE); RECORD(DECL_NAMESPACE_ALIAS); RECORD(DECL_USING); RECORD(DECL_USING_SHADOW); RECORD(DECL_USING_DIRECTIVE); RECORD(DECL_UNRESOLVED_USING_VALUE); RECORD(DECL_UNRESOLVED_USING_TYPENAME); RECORD(DECL_LINKAGE_SPEC); RECORD(DECL_CXX_RECORD); RECORD(DECL_CXX_METHOD); RECORD(DECL_CXX_CONSTRUCTOR); RECORD(DECL_CXX_DESTRUCTOR); RECORD(DECL_CXX_CONVERSION); RECORD(DECL_ACCESS_SPEC); RECORD(DECL_FRIEND); RECORD(DECL_FRIEND_TEMPLATE); RECORD(DECL_CLASS_TEMPLATE); RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION); RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION); RECORD(DECL_VAR_TEMPLATE); RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION); RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION); RECORD(DECL_FUNCTION_TEMPLATE); RECORD(DECL_TEMPLATE_TYPE_PARM); RECORD(DECL_NON_TYPE_TEMPLATE_PARM); RECORD(DECL_TEMPLATE_TEMPLATE_PARM); RECORD(DECL_STATIC_ASSERT); RECORD(DECL_CXX_BASE_SPECIFIERS); RECORD(DECL_INDIRECTFIELD); RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK); // Statements and Exprs can occur in the Decls and Types block. AddStmtsExprs(Stream, Record); BLOCK(PREPROCESSOR_DETAIL_BLOCK); RECORD(PPD_MACRO_EXPANSION); RECORD(PPD_MACRO_DEFINITION); RECORD(PPD_INCLUSION_DIRECTIVE); #undef RECORD #undef BLOCK Stream.ExitBlock(); } /// \brief Adjusts the given filename to only write out the portion of the /// filename that is not part of the system root directory. /// /// \param Filename the file name to adjust. /// /// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and /// the returned filename will be adjusted by this system root. /// /// \returns either the original filename (if it needs no adjustment) or the /// adjusted filename (which points into the @@p Filename parameter). static const char * adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) { assert(Filename && "No file name to adjust?"); if (isysroot.empty()) return Filename; // Verify that the filename and the system root have the same prefix. unsigned Pos = 0; for (; Filename[Pos] && Pos < isysroot.size(); ++Pos) if (Filename[Pos] != isysroot[Pos]) return Filename; // Prefixes don't match. // We hit the end of the filename before we hit the end of the system root. if (!Filename[Pos]) return Filename; // If the file name has a '/' at the current position, skip over the '/'. // We distinguish sysroot-based includes from absolute includes by the // absence of '/' at the beginning of sysroot-based includes. if (Filename[Pos] == '/') ++Pos; return Filename + Pos; } /// \brief Write the control block. void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, StringRef isysroot, const std::string &OutputFile) { using namespace llvm; Stream.EnterSubblock(CONTROL_BLOCK_ID, 5); RecordData Record; // Metadata BitCodeAbbrev *MetadataAbbrev = new BitCodeAbbrev(); MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA)); MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj. MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min. MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev); Record.push_back(METADATA); Record.push_back(VERSION_MAJOR); Record.push_back(VERSION_MINOR); Record.push_back(CLANG_VERSION_MAJOR); Record.push_back(CLANG_VERSION_MINOR); Record.push_back(!isysroot.empty()); Record.push_back(ASTHasCompilerErrors); Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, getClangFullRepositoryVersion()); // Module name if (WritingModule) { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(MODULE_NAME); Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name); } // Module map file if (WritingModule) { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_MAP_FILE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Filename unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); const FileEntry *ModMapFile = PP.getHeaderSearchInfo().getModuleMap(). getModuleMapFileForUniquing(WritingModule); SmallString<128> ModuleMap(ModMapFile->getName()); llvm::sys::fs::make_absolute(ModuleMap); RecordData Record; Record.push_back(MODULE_MAP_FILE); Stream.EmitRecordWithBlob(AbbrevCode, Record, ModuleMap.str()); } // Imports if (Chain) { serialization::ModuleManager &Mgr = Chain->getModuleManager(); Record.clear(); for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end(); M != MEnd; ++M) { // Skip modules that weren't directly imported. if (!(*M)->isDirectlyImported()) continue; Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding AddSourceLocation((*M)->ImportLoc, Record); Record.push_back((*M)->File->getSize()); Record.push_back((*M)->File->getModificationTime()); const std::string &FileName = (*M)->FileName; Record.push_back(FileName.size()); Record.append(FileName.begin(), FileName.end()); } Stream.EmitRecord(IMPORTS, Record); } // Language options. Record.clear(); const LangOptions &LangOpts = Context.getLangOpts(); #define LANGOPT(Name, Bits, Default, Description) \ Record.push_back(LangOpts.Name); #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ Record.push_back(static_cast(LangOpts.get##Name())); #include "clang/Basic/LangOptions.def" #define SANITIZER(NAME, ID) Record.push_back(LangOpts.Sanitize.ID); #include "clang/Basic/Sanitizers.def" Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind()); AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record); Record.push_back(LangOpts.CurrentModule.size()); Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end()); // Comment options. Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size()); for (CommentOptions::BlockCommandNamesTy::const_iterator I = LangOpts.CommentOpts.BlockCommandNames.begin(), IEnd = LangOpts.CommentOpts.BlockCommandNames.end(); I != IEnd; ++I) { AddString(*I, Record); } Record.push_back(LangOpts.CommentOpts.ParseAllComments); Stream.EmitRecord(LANGUAGE_OPTIONS, Record); // Target options. Record.clear(); const TargetInfo &Target = Context.getTargetInfo(); const TargetOptions &TargetOpts = Target.getTargetOpts(); AddString(TargetOpts.Triple, Record); AddString(TargetOpts.CPU, Record); AddString(TargetOpts.ABI, Record); Record.push_back(TargetOpts.FeaturesAsWritten.size()); for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) { AddString(TargetOpts.FeaturesAsWritten[I], Record); } Record.push_back(TargetOpts.Features.size()); for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) { AddString(TargetOpts.Features[I], Record); } Stream.EmitRecord(TARGET_OPTIONS, Record); // Diagnostic options. Record.clear(); const DiagnosticOptions &DiagOpts = Context.getDiagnostics().getDiagnosticOptions(); #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name); #define ENUM_DIAGOPT(Name, Type, Bits, Default) \ Record.push_back(static_cast(DiagOpts.get##Name())); #include "clang/Basic/DiagnosticOptions.def" Record.push_back(DiagOpts.Warnings.size()); for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I) AddString(DiagOpts.Warnings[I], Record); Record.push_back(DiagOpts.Remarks.size()); for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I) AddString(DiagOpts.Remarks[I], Record); // Note: we don't serialize the log or serialization file names, because they // are generally transient files and will almost always be overridden. Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record); // File system options. Record.clear(); const FileSystemOptions &FSOpts = Context.getSourceManager().getFileManager().getFileSystemOptions(); AddString(FSOpts.WorkingDir, Record); Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record); // Header search options. Record.clear(); const HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); AddString(HSOpts.Sysroot, Record); // Include entries. Record.push_back(HSOpts.UserEntries.size()); for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) { const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I]; AddString(Entry.Path, Record); Record.push_back(static_cast(Entry.Group)); Record.push_back(Entry.IsFramework); Record.push_back(Entry.IgnoreSysRoot); } // System header prefixes. Record.push_back(HSOpts.SystemHeaderPrefixes.size()); for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) { AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record); Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader); } AddString(HSOpts.ResourceDir, Record); AddString(HSOpts.ModuleCachePath, Record); AddString(HSOpts.ModuleUserBuildPath, Record); Record.push_back(HSOpts.DisableModuleHash); Record.push_back(HSOpts.UseBuiltinIncludes); Record.push_back(HSOpts.UseStandardSystemIncludes); Record.push_back(HSOpts.UseStandardCXXIncludes); Record.push_back(HSOpts.UseLibcxx); Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record); // Preprocessor options. Record.clear(); const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts(); // Macro definitions. Record.push_back(PPOpts.Macros.size()); for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { AddString(PPOpts.Macros[I].first, Record); Record.push_back(PPOpts.Macros[I].second); } // Includes Record.push_back(PPOpts.Includes.size()); for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I) AddString(PPOpts.Includes[I], Record); // Macro includes Record.push_back(PPOpts.MacroIncludes.size()); for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I) AddString(PPOpts.MacroIncludes[I], Record); Record.push_back(PPOpts.UsePredefines); // Detailed record is important since it is used for the module cache hash. Record.push_back(PPOpts.DetailedRecord); AddString(PPOpts.ImplicitPCHInclude, Record); AddString(PPOpts.ImplicitPTHInclude, Record); Record.push_back(static_cast(PPOpts.ObjCXXARCStandardLibrary)); Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record); // Original file name and file ID SourceManager &SM = Context.getSourceManager(); if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev(); FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE)); FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); SmallString<128> MainFilePath(MainFile->getName()); llvm::sys::fs::make_absolute(MainFilePath); const char *MainFileNameStr = MainFilePath.c_str(); MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, isysroot); Record.clear(); Record.push_back(ORIGINAL_FILE); Record.push_back(SM.getMainFileID().getOpaqueValue()); Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr); } Record.clear(); Record.push_back(SM.getMainFileID().getOpaqueValue()); Stream.EmitRecord(ORIGINAL_FILE_ID, Record); // Original PCH directory if (!OutputFile.empty() && OutputFile != "-") { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); SmallString<128> OutputPath(OutputFile); llvm::sys::fs::make_absolute(OutputPath); StringRef origDir = llvm::sys::path::parent_path(OutputPath); RecordData Record; Record.push_back(ORIGINAL_PCH_DIR); Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); } WriteInputFiles(Context.SourceMgr, PP.getHeaderSearchInfo().getHeaderSearchOpts(), isysroot, PP.getLangOpts().Modules); Stream.ExitBlock(); } namespace { /// \brief An input file. struct InputFileEntry { const FileEntry *File; bool IsSystemFile; bool BufferOverridden; }; } void ASTWriter::WriteInputFiles(SourceManager &SourceMgr, HeaderSearchOptions &HSOpts, StringRef isysroot, bool Modules) { using namespace llvm; Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4); RecordData Record; // Create input-file abbreviation. BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev(); IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE)); IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev); // Get all ContentCache objects for files, sorted by whether the file is a // system one or not. System files go at the back, users files at the front. std::deque SortedFiles; for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { // Get this source location entry. const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc); // We only care about file entries that were not overridden. if (!SLoc->isFile()) continue; const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); if (!Cache->OrigEntry) continue; InputFileEntry Entry; Entry.File = Cache->OrigEntry; Entry.IsSystemFile = Cache->IsSystemFile; Entry.BufferOverridden = Cache->BufferOverridden; if (Cache->IsSystemFile) SortedFiles.push_back(Entry); else SortedFiles.push_front(Entry); } unsigned UserFilesNum = 0; // Write out all of the input files. std::vector InputFileOffsets; for (std::deque::iterator I = SortedFiles.begin(), E = SortedFiles.end(); I != E; ++I) { const InputFileEntry &Entry = *I; uint32_t &InputFileID = InputFileIDs[Entry.File]; if (InputFileID != 0) continue; // already recorded this file. // Record this entry's offset. InputFileOffsets.push_back(Stream.GetCurrentBitNo()); InputFileID = InputFileOffsets.size(); if (!Entry.IsSystemFile) ++UserFilesNum; Record.clear(); Record.push_back(INPUT_FILE); Record.push_back(InputFileOffsets.size()); // Emit size/modification time for this file. Record.push_back(Entry.File->getSize()); Record.push_back(Entry.File->getModificationTime()); // Whether this file was overridden. Record.push_back(Entry.BufferOverridden); // Turn the file name into an absolute path, if it isn't already. const char *Filename = Entry.File->getName(); SmallString<128> FilePath(Filename); // Ask the file manager to fixup the relative path for us. This will // honor the working directory. SourceMgr.getFileManager().FixupRelativePath(FilePath); // FIXME: This call to make_absolute shouldn't be necessary, the // call to FixupRelativePath should always return an absolute path. llvm::sys::fs::make_absolute(FilePath); Filename = FilePath.c_str(); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); Stream.EmitRecordWithBlob(IFAbbrevCode, Record, Filename); } Stream.ExitBlock(); // Create input file offsets abbreviation. BitCodeAbbrev *OffsetsAbbrev = new BitCodeAbbrev(); OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS)); OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system // input files OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev); // Write input file offsets. Record.clear(); Record.push_back(INPUT_FILE_OFFSETS); Record.push_back(InputFileOffsets.size()); Record.push_back(UserFilesNum); Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, data(InputFileOffsets)); } //===----------------------------------------------------------------------===// // Source Manager Serialization //===----------------------------------------------------------------------===// /// \brief Create an abbreviation for the SLocEntry that refers to a /// file. static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives // FileEntry fields. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer. static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer's blob. static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a macro /// expansion. static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length return Stream.EmitAbbrev(Abbrev); } namespace { // Trait used for the on-disk hash table of header search information. class HeaderFileInfoTrait { ASTWriter &Writer; const HeaderSearch &HS; // Keep track of the framework names we've used during serialization. SmallVector FrameworkStringData; llvm::StringMap FrameworkNameOffset; public: HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS) : Writer(Writer), HS(HS) { } struct key_type { const FileEntry *FE; const char *Filename; }; typedef const key_type &key_type_ref; typedef HeaderFileInfo data_type; typedef const data_type &data_type_ref; typedef unsigned hash_value_type; typedef unsigned offset_type; static hash_value_type ComputeHash(key_type_ref key) { // The hash is based only on size/time of the file, so that the reader can // match even when symlinking or excess path elements ("foo/../", "../") // change the form of the name. However, complete path is still the key. return llvm::hash_combine(key.FE->getSize(), key.FE->getModificationTime()); } std::pair EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) { using namespace llvm::support; endian::Writer Writer(Out); unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8; Writer.write(KeyLen); unsigned DataLen = 1 + 2 + 4 + 4; if (Data.isModuleHeader) DataLen += 4; Writer.write(DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) { using namespace llvm::support; endian::Writer LE(Out); LE.write(key.FE->getSize()); KeyLen -= 8; LE.write(key.FE->getModificationTime()); KeyLen -= 8; Out.write(key.Filename, KeyLen); } void EmitData(raw_ostream &Out, key_type_ref key, data_type_ref Data, unsigned DataLen) { using namespace llvm::support; endian::Writer LE(Out); uint64_t Start = Out.tell(); (void)Start; unsigned char Flags = (Data.HeaderRole << 6) | (Data.isImport << 5) | (Data.isPragmaOnce << 4) | (Data.DirInfo << 2) | (Data.Resolved << 1) | Data.IndexHeaderMapHeader; LE.write(Flags); LE.write(Data.NumIncludes); if (!Data.ControllingMacro) LE.write(Data.ControllingMacroID); else LE.write(Writer.getIdentifierRef(Data.ControllingMacro)); unsigned Offset = 0; if (!Data.Framework.empty()) { // If this header refers into a framework, save the framework name. llvm::StringMap::iterator Pos = FrameworkNameOffset.find(Data.Framework); if (Pos == FrameworkNameOffset.end()) { Offset = FrameworkStringData.size() + 1; FrameworkStringData.append(Data.Framework.begin(), Data.Framework.end()); FrameworkStringData.push_back(0); FrameworkNameOffset[Data.Framework] = Offset; } else Offset = Pos->second; } LE.write(Offset); if (Data.isModuleHeader) { Module *Mod = HS.findModuleForHeader(key.FE).getModule(); LE.write(Writer.getExistingSubmoduleID(Mod)); } assert(Out.tell() - Start == DataLen && "Wrong data length"); } const char *strings_begin() const { return FrameworkStringData.begin(); } const char *strings_end() const { return FrameworkStringData.end(); } }; } // end anonymous namespace /// \brief Write the header search block for the list of files that /// /// \param HS The header search structure to save. void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) { SmallVector FilesByUID; HS.getFileMgr().GetUniqueIDMapping(FilesByUID); if (FilesByUID.size() > HS.header_file_size()) FilesByUID.resize(HS.header_file_size()); HeaderFileInfoTrait GeneratorTrait(*this, HS); llvm::OnDiskChainedHashTableGenerator Generator; SmallVector SavedStrings; unsigned NumHeaderSearchEntries = 0; for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { const FileEntry *File = FilesByUID[UID]; if (!File) continue; // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo // from the external source if it was not provided already. HeaderFileInfo HFI; if (!HS.tryGetFileInfo(File, HFI) || (HFI.External && Chain) || (HFI.isModuleHeader && !HFI.isCompilingModuleHeader)) continue; // Turn the file name into an absolute path, if it isn't already. const char *Filename = File->getName(); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); // If we performed any translation on the file name at all, we need to // save this string, since the generator will refer to it later. if (Filename != File->getName()) { Filename = strdup(Filename); SavedStrings.push_back(Filename); } HeaderFileInfoTrait::key_type key = { File, Filename }; Generator.insert(key, HFI, GeneratorTrait); ++NumHeaderSearchEntries; } // Create the on-disk hash table in a buffer. SmallString<4096> TableData; uint32_t BucketOffset; { using namespace llvm::support; llvm::raw_svector_ostream Out(TableData); // Make sure that no bucket is at offset 0 endian::Writer(Out).write(0); BucketOffset = Generator.Emit(Out, GeneratorTrait); } // Create a blob abbreviation using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); // Write the header search table RecordData Record; Record.push_back(HEADER_SEARCH_TABLE); Record.push_back(BucketOffset); Record.push_back(NumHeaderSearchEntries); Record.push_back(TableData.size()); TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str()); // Free all of the strings we had to duplicate. for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) free(const_cast(SavedStrings[I])); } /// \brief Writes the block containing the serialized form of the /// source manager. /// /// TODO: We should probably use an on-disk hash table (stored in a /// blob), indexed based on the file name, so that we only create /// entries for files that we actually need. In the common case (no /// errors), we probably won't have to create file entries for any of /// the files in the AST. void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, const Preprocessor &PP, StringRef isysroot) { RecordData Record; // Enter the source manager block. Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3); // Abbreviations for the various kinds of source-location entries. unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream); // Write out the source location entry table. We skip the first // entry, which is always the same dummy entry. std::vector SLocEntryOffsets; RecordData PreloadSLocs; SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1); for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { // Get this source location entry. const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); FileID FID = FileID::get(I); assert(&SourceMgr.getSLocEntry(FID) == SLoc); // Record the offset of this source-location entry. SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); // Figure out which record code to use. unsigned Code; if (SLoc->isFile()) { const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); if (Cache->OrigEntry) { Code = SM_SLOC_FILE_ENTRY; } else Code = SM_SLOC_BUFFER_ENTRY; } else Code = SM_SLOC_EXPANSION_ENTRY; Record.clear(); Record.push_back(Code); // Starting offset of this entry within this module, so skip the dummy. Record.push_back(SLoc->getOffset() - 2); if (SLoc->isFile()) { const SrcMgr::FileInfo &File = SLoc->getFile(); Record.push_back(File.getIncludeLoc().getRawEncoding()); Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding Record.push_back(File.hasLineDirectives()); const SrcMgr::ContentCache *Content = File.getContentCache(); if (Content->OrigEntry) { assert(Content->OrigEntry == Content->ContentsEntry && "Writing to AST an overridden file is not supported"); // The source location entry is a file. Emit input file ID. assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry"); Record.push_back(InputFileIDs[Content->OrigEntry]); Record.push_back(File.NumCreatedFIDs); FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID); if (FDI != FileDeclIDs.end()) { Record.push_back(FDI->second->FirstDeclIndex); Record.push_back(FDI->second->DeclIDs.size()); } else { Record.push_back(0); Record.push_back(0); } Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record); if (Content->BufferOverridden) { Record.clear(); Record.push_back(SM_SLOC_BUFFER_BLOB); const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, StringRef(Buffer->getBufferStart(), Buffer->getBufferSize() + 1)); } } else { // The source location entry is a buffer. The blob associated // with this entry contains the contents of the buffer. // We add one to the size so that we capture the trailing NULL // that is required by llvm::MemoryBuffer::getMemBuffer (on // the reader side). const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); const char *Name = Buffer->getBufferIdentifier(); Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, StringRef(Name, strlen(Name) + 1)); Record.clear(); Record.push_back(SM_SLOC_BUFFER_BLOB); Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, StringRef(Buffer->getBufferStart(), Buffer->getBufferSize() + 1)); if (strcmp(Name, "") == 0) { PreloadSLocs.push_back(SLocEntryOffsets.size()); } } } else { // The source location entry is a macro expansion. const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); Record.push_back(Expansion.getSpellingLoc().getRawEncoding()); Record.push_back(Expansion.getExpansionLocStart().getRawEncoding()); Record.push_back(Expansion.isMacroArgExpansion() ? 0 : Expansion.getExpansionLocEnd().getRawEncoding()); // Compute the token length for this macro expansion. unsigned NextOffset = SourceMgr.getNextLocalOffset(); if (I + 1 != N) NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset(); Record.push_back(NextOffset - SLoc->getOffset() - 1); Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record); } } Stream.ExitBlock(); if (SLocEntryOffsets.empty()) return; // Write the source-location offsets table into the AST block. This // table is used for lazily loading source-location information. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(SOURCE_LOCATION_OFFSETS); Record.push_back(SLocEntryOffsets.size()); Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets)); // Write the source location entry preloads array, telling the AST // reader which source locations entries it should load eagerly. Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); // Write the line table. It depends on remapping working, so it must come // after the source location offsets. if (SourceMgr.hasLineTable()) { LineTableInfo &LineTable = SourceMgr.getLineTable(); Record.clear(); // Emit the file names Record.push_back(LineTable.getNumFilenames()); for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) { // Emit the file name const char *Filename = LineTable.getFilename(I); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); unsigned FilenameLen = Filename? strlen(Filename) : 0; Record.push_back(FilenameLen); if (FilenameLen) Record.insert(Record.end(), Filename, Filename + FilenameLen); } // Emit the line entries for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); L != LEnd; ++L) { // Only emit entries for local files. if (L->first.ID < 0) continue; // Emit the file ID Record.push_back(L->first.ID); // Emit the line entries Record.push_back(L->second.size()); for (std::vector::iterator LE = L->second.begin(), LEEnd = L->second.end(); LE != LEEnd; ++LE) { Record.push_back(LE->FileOffset); Record.push_back(LE->LineNo); Record.push_back(LE->FilenameID); Record.push_back((unsigned)LE->FileKind); Record.push_back(LE->IncludeOffset); } } Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record); } } //===----------------------------------------------------------------------===// // Preprocessor Serialization //===----------------------------------------------------------------------===// namespace { class ASTMacroTableTrait { public: typedef IdentID key_type; typedef key_type key_type_ref; struct Data { uint32_t MacroDirectivesOffset; }; typedef Data data_type; typedef const data_type &data_type_ref; typedef unsigned hash_value_type; typedef unsigned offset_type; static hash_value_type ComputeHash(IdentID IdID) { return llvm::hash_value(IdID); } std::pair static EmitKeyDataLength(raw_ostream& Out, key_type_ref Key, data_type_ref Data) { unsigned KeyLen = 4; // IdentID. unsigned DataLen = 4; // MacroDirectivesOffset. return std::make_pair(KeyLen, DataLen); } static void EmitKey(raw_ostream& Out, key_type_ref Key, unsigned KeyLen) { using namespace llvm::support; endian::Writer(Out).write(Key); } static void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data, unsigned) { using namespace llvm::support; endian::Writer(Out).write(Data.MacroDirectivesOffset); } }; } // end anonymous namespace static int compareMacroDirectives( const std::pair *X, const std::pair *Y) { return X->first->getName().compare(Y->first->getName()); } static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule, const Preprocessor &PP) { if (MacroInfo *MI = MD->getMacroInfo()) if (MI->isBuiltinMacro()) return true; if (IsModule) { // Re-export any imported directives. if (MD->isImported()) return false; SourceLocation Loc = MD->getLocation(); if (Loc.isInvalid()) return true; if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID()) return true; } return false; } /// \brief Writes the block containing the serialized form of the /// preprocessor. /// void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); if (PPRec) WritePreprocessorDetail(*PPRec); RecordData Record; // If the preprocessor __COUNTER__ value has been bumped, remember it. if (PP.getCounterValue() != 0) { Record.push_back(PP.getCounterValue()); Stream.EmitRecord(PP_COUNTER_VALUE, Record); Record.clear(); } // Enter the preprocessor block. Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); // If the AST file contains __DATE__ or __TIME__ emit a warning about this. // FIXME: use diagnostics subsystem for localization etc. if (PP.SawDateOrTime()) fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); // Loop over all the macro directives that are live at the end of the file, // emitting each to the PP section. // Construct the list of macro directives that need to be serialized. SmallVector, 2> MacroDirectives; for (Preprocessor::macro_iterator I = PP.macro_begin(/*IncludeExternalMacros=*/false), E = PP.macro_end(/*IncludeExternalMacros=*/false); I != E; ++I) { MacroDirectives.push_back(std::make_pair(I->first, I->second)); } // Sort the set of macro definitions that need to be serialized by the // name of the macro, to provide a stable ordering. llvm::array_pod_sort(MacroDirectives.begin(), MacroDirectives.end(), &compareMacroDirectives); llvm::OnDiskChainedHashTableGenerator Generator; // Emit the macro directives as a list and associate the offset with the // identifier they belong to. for (unsigned I = 0, N = MacroDirectives.size(); I != N; ++I) { const IdentifierInfo *Name = MacroDirectives[I].first; uint64_t MacroDirectiveOffset = Stream.GetCurrentBitNo(); MacroDirective *MD = MacroDirectives[I].second; // If the macro or identifier need no updates, don't write the macro history // for this one. // FIXME: Chain the macro history instead of re-writing it. if (MD->isFromPCH() && Name->isFromAST() && !Name->hasChangedSinceDeserialization()) continue; // Emit the macro directives in reverse source order. for (; MD; MD = MD->getPrevious()) { if (shouldIgnoreMacro(MD, IsModule, PP)) continue; AddSourceLocation(MD->getLocation(), Record); Record.push_back(MD->getKind()); if (auto *DefMD = dyn_cast(MD)) { MacroID InfoID = getMacroRef(DefMD->getInfo(), Name); Record.push_back(InfoID); Record.push_back(DefMD->getOwningModuleID()); Record.push_back(DefMD->isAmbiguous()); } else if (auto *UndefMD = dyn_cast(MD)) { Record.push_back(UndefMD->getOwningModuleID()); } else { auto *VisMD = cast(MD); Record.push_back(VisMD->isPublic()); } if (MD->isImported()) { auto Overrides = MD->getOverriddenModules(); Record.push_back(Overrides.size()); for (auto Override : Overrides) Record.push_back(Override); } } if (Record.empty()) continue; Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record); Record.clear(); IdentMacroDirectivesOffsetMap[Name] = MacroDirectiveOffset; IdentID NameID = getIdentifierRef(Name); ASTMacroTableTrait::Data data; data.MacroDirectivesOffset = MacroDirectiveOffset; Generator.insert(NameID, data); } /// \brief Offsets of each of the macros into the bitstream, indexed by /// the local macro ID /// /// For each identifier that is associated with a macro, this map /// provides the offset into the bitstream where that macro is /// defined. std::vector MacroOffsets; for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) { const IdentifierInfo *Name = MacroInfosToEmit[I].Name; MacroInfo *MI = MacroInfosToEmit[I].MI; MacroID ID = MacroInfosToEmit[I].ID; if (ID < FirstMacroID) { assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?"); continue; } // Record the local offset of this macro. unsigned Index = ID - FirstMacroID; if (Index == MacroOffsets.size()) MacroOffsets.push_back(Stream.GetCurrentBitNo()); else { if (Index > MacroOffsets.size()) MacroOffsets.resize(Index + 1); MacroOffsets[Index] = Stream.GetCurrentBitNo(); } AddIdentifierRef(Name, Record); Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc())); AddSourceLocation(MI->getDefinitionLoc(), Record); AddSourceLocation(MI->getDefinitionEndLoc(), Record); Record.push_back(MI->isUsed()); Record.push_back(MI->isUsedForHeaderGuard()); unsigned Code; if (MI->isObjectLike()) { Code = PP_MACRO_OBJECT_LIKE; } else { Code = PP_MACRO_FUNCTION_LIKE; Record.push_back(MI->isC99Varargs()); Record.push_back(MI->isGNUVarargs()); Record.push_back(MI->hasCommaPasting()); Record.push_back(MI->getNumArgs()); for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end(); I != E; ++I) AddIdentifierRef(*I, Record); } // If we have a detailed preprocessing record, record the macro definition // ID that corresponds to this macro. if (PPRec) Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]); Stream.EmitRecord(Code, Record); Record.clear(); // Emit the tokens array. for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { // Note that we know that the preprocessor does not have any annotation // tokens in it because they are created by the parser, and thus can't // be in a macro definition. const Token &Tok = MI->getReplacementToken(TokNo); AddToken(Tok, Record); Stream.EmitRecord(PP_TOKEN, Record); Record.clear(); } ++NumMacros; } Stream.ExitBlock(); // Create the on-disk hash table in a buffer. SmallString<4096> MacroTable; uint32_t BucketOffset; { using namespace llvm::support; llvm::raw_svector_ostream Out(MacroTable); // Make sure that no bucket is at offset 0 endian::Writer(Out).write(0); BucketOffset = Generator.Emit(Out); } // Write the macro table using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MACRO_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MacroTableAbbrev = Stream.EmitAbbrev(Abbrev); Record.push_back(MACRO_TABLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(MacroTableAbbrev, Record, MacroTable.str()); Record.clear(); // Write the offsets table for macro IDs. using namespace llvm; Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(MACRO_OFFSET); Record.push_back(MacroOffsets.size()); Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS); Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, data(MacroOffsets)); } void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { if (PPRec.local_begin() == PPRec.local_end()) return; SmallVector PreprocessedEntityOffsets; // Enter the preprocessor block. Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); // If the preprocessor has a preprocessing record, emit it. unsigned NumPreprocessingRecords = 0; using namespace llvm; // Set up the abbreviation for unsigned InclusionAbbrev = 0; { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); InclusionAbbrev = Stream.EmitAbbrev(Abbrev); } unsigned FirstPreprocessorEntityID = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) + NUM_PREDEF_PP_ENTITY_IDS; unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; RecordData Record; for (PreprocessingRecord::iterator E = PPRec.local_begin(), EEnd = PPRec.local_end(); E != EEnd; (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { Record.clear(); PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo())); if (MacroDefinition *MD = dyn_cast(*E)) { // Record this macro definition's ID. MacroDefinitions[MD] = NextPreprocessorEntityID; AddIdentifierRef(MD->getName(), Record); Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); continue; } if (MacroExpansion *ME = dyn_cast(*E)) { Record.push_back(ME->isBuiltinMacro()); if (ME->isBuiltinMacro()) AddIdentifierRef(ME->getName(), Record); else Record.push_back(MacroDefinitions[ME->getDefinition()]); Stream.EmitRecord(PPD_MACRO_EXPANSION, Record); continue; } if (InclusionDirective *ID = dyn_cast(*E)) { Record.push_back(PPD_INCLUSION_DIRECTIVE); Record.push_back(ID->getFileName().size()); Record.push_back(ID->wasInQuotes()); Record.push_back(static_cast(ID->getKind())); Record.push_back(ID->importedModule()); SmallString<64> Buffer; Buffer += ID->getFileName(); // Check that the FileEntry is not null because it was not resolved and // we create a PCH even with compiler errors. if (ID->getFile()) Buffer += ID->getFile()->getName(); Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); continue; } llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); } Stream.ExitBlock(); // Write the offsets table for the preprocessing record. if (NumPreprocessingRecords > 0) { assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords); // Write the offsets table for identifier IDs. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(PPD_ENTITIES_OFFSETS); Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS); Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, data(PreprocessedEntityOffsets)); } } unsigned ASTWriter::getSubmoduleID(Module *Mod) { llvm::DenseMap::iterator Known = SubmoduleIDs.find(Mod); if (Known != SubmoduleIDs.end()) return Known->second; return SubmoduleIDs[Mod] = NextSubmoduleID++; } unsigned ASTWriter::getExistingSubmoduleID(Module *Mod) const { if (!Mod) return 0; llvm::DenseMap::const_iterator Known = SubmoduleIDs.find(Mod); if (Known != SubmoduleIDs.end()) return Known->second; return 0; } /// \brief Compute the number of modules within the given tree (including the /// given module). static unsigned getNumberOfModules(Module *Mod) { unsigned ChildModules = 0; for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) ChildModules += getNumberOfModules(*Sub); return ChildModules + 1; } void ASTWriter::WriteSubmodules(Module *WritingModule) { // Determine the dependencies of our module and each of it's submodules. // FIXME: This feels like it belongs somewhere else, but there are no // other consumers of this information. SourceManager &SrcMgr = PP->getSourceManager(); ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); for (const auto *I : Context->local_imports()) { if (Module *ImportedFrom = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(), SrcMgr))) { ImportedFrom->Imports.push_back(I->getImportedModule()); } } // Enter the submodule description block. Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/4); // Write the abbreviations needed for the submodules block. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev); // Write the submodule metadata block. RecordData Record; Record.push_back(getNumberOfModules(WritingModule)); Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS); Stream.EmitRecord(SUBMODULE_METADATA, Record); // Write all of the submodules. std::queue Q; Q.push(WritingModule); while (!Q.empty()) { Module *Mod = Q.front(); Q.pop(); unsigned ID = getSubmoduleID(Mod); // Emit the definition of the block. Record.clear(); Record.push_back(SUBMODULE_DEFINITION); Record.push_back(ID); if (Mod->Parent) { assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); Record.push_back(SubmoduleIDs[Mod->Parent]); } else { Record.push_back(0); } Record.push_back(Mod->IsFramework); Record.push_back(Mod->IsExplicit); Record.push_back(Mod->IsSystem); Record.push_back(Mod->IsExternC); Record.push_back(Mod->InferSubmodules); Record.push_back(Mod->InferExplicitSubmodules); Record.push_back(Mod->InferExportWildcard); Record.push_back(Mod->ConfigMacrosExhaustive); Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); // Emit the requirements. for (unsigned I = 0, N = Mod->Requirements.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_REQUIRES); Record.push_back(Mod->Requirements[I].second); Stream.EmitRecordWithBlob(RequiresAbbrev, Record, Mod->Requirements[I].first); } // Emit the umbrella header, if there is one. if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) { Record.clear(); Record.push_back(SUBMODULE_UMBRELLA_HEADER); Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, UmbrellaHeader->getName()); } else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) { Record.clear(); Record.push_back(SUBMODULE_UMBRELLA_DIR); Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, UmbrellaDir->getName()); } // Emit the headers. for (unsigned I = 0, N = Mod->NormalHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_HEADER); Stream.EmitRecordWithBlob(HeaderAbbrev, Record, Mod->NormalHeaders[I]->getName()); } // Emit the excluded headers. for (unsigned I = 0, N = Mod->ExcludedHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_EXCLUDED_HEADER); Stream.EmitRecordWithBlob(ExcludedHeaderAbbrev, Record, Mod->ExcludedHeaders[I]->getName()); } // Emit the private headers. for (unsigned I = 0, N = Mod->PrivateHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_PRIVATE_HEADER); Stream.EmitRecordWithBlob(PrivateHeaderAbbrev, Record, Mod->PrivateHeaders[I]->getName()); } ArrayRef TopHeaders = Mod->getTopHeaders(PP->getFileManager()); for (unsigned I = 0, N = TopHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_TOPHEADER); Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, TopHeaders[I]->getName()); } // Emit the imports. if (!Mod->Imports.empty()) { Record.clear(); for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { unsigned ImportedID = getSubmoduleID(Mod->Imports[I]); assert(ImportedID && "Unknown submodule!"); Record.push_back(ImportedID); } Stream.EmitRecord(SUBMODULE_IMPORTS, Record); } // Emit the exports. if (!Mod->Exports.empty()) { Record.clear(); for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { if (Module *Exported = Mod->Exports[I].getPointer()) { unsigned ExportedID = SubmoduleIDs[Exported]; assert(ExportedID > 0 && "Unknown submodule ID?"); Record.push_back(ExportedID); } else { Record.push_back(0); } Record.push_back(Mod->Exports[I].getInt()); } Stream.EmitRecord(SUBMODULE_EXPORTS, Record); } //FIXME: How do we emit the 'use'd modules? They may not be submodules. // Might be unnecessary as use declarations are only used to build the // module itself. // Emit the link libraries. for (unsigned I = 0, N = Mod->LinkLibraries.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_LINK_LIBRARY); Record.push_back(Mod->LinkLibraries[I].IsFramework); Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, Mod->LinkLibraries[I].Library); } // Emit the conflicts. for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_CONFLICT); unsigned OtherID = getSubmoduleID(Mod->Conflicts[I].Other); assert(OtherID && "Unknown submodule!"); Record.push_back(OtherID); Stream.EmitRecordWithBlob(ConflictAbbrev, Record, Mod->Conflicts[I].Message); } // Emit the configuration macros. for (unsigned I = 0, N = Mod->ConfigMacros.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_CONFIG_MACRO); Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, Mod->ConfigMacros[I]); } // Queue up the submodules of this module. for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) Q.push(*Sub); } Stream.ExitBlock(); assert((NextSubmoduleID - FirstSubmoduleID == getNumberOfModules(WritingModule)) && "Wrong # of submodules"); } serialization::SubmoduleID ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) { if (Loc.isInvalid() || !WritingModule) return 0; // No submodule // Find the module that owns this location. ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); Module *OwningMod = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager())); if (!OwningMod) return 0; // Check whether this submodule is part of our own module. if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule)) return 0; return getSubmoduleID(OwningMod); } void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag, bool isModule) { // Make sure set diagnostic pragmas don't affect the translation unit that // imports the module. // FIXME: Make diagnostic pragma sections work properly with modules. if (isModule) return; llvm::SmallDenseMap DiagStateIDMap; unsigned CurrID = 0; DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one. RecordData Record; for (DiagnosticsEngine::DiagStatePointsTy::const_iterator I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end(); I != E; ++I) { const DiagnosticsEngine::DiagStatePoint &point = *I; if (point.Loc.isInvalid()) continue; Record.push_back(point.Loc.getRawEncoding()); unsigned &DiagStateID = DiagStateIDMap[point.State]; Record.push_back(DiagStateID); if (DiagStateID == 0) { DiagStateID = ++CurrID; for (DiagnosticsEngine::DiagState::const_iterator I = point.State->begin(), E = point.State->end(); I != E; ++I) { if (I->second.isPragma()) { Record.push_back(I->first); Record.push_back((unsigned)I->second.getSeverity()); } } Record.push_back(-1); // mark the end of the diag/map pairs for this // location. } } if (!Record.empty()) Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); } void ASTWriter::WriteCXXBaseSpecifiersOffsets() { if (CXXBaseSpecifiersOffsets.empty()) return; RecordData Record; // Create a blob abbreviation for the C++ base specifiers offsets. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); // Write the base specifier offsets table. Record.clear(); Record.push_back(CXX_BASE_SPECIFIER_OFFSETS); Record.push_back(CXXBaseSpecifiersOffsets.size()); Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record, data(CXXBaseSpecifiersOffsets)); } //===----------------------------------------------------------------------===// // Type Serialization //===----------------------------------------------------------------------===// /// \brief Write the representation of a type to the AST stream. void ASTWriter::WriteType(QualType T) { TypeIdx &Idx = TypeIdxs[T]; if (Idx.getIndex() == 0) // we haven't seen this type before. Idx = TypeIdx(NextTypeID++); assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); // Record the offset for this type. unsigned Index = Idx.getIndex() - FirstTypeID; if (TypeOffsets.size() == Index) TypeOffsets.push_back(Stream.GetCurrentBitNo()); else if (TypeOffsets.size() < Index) { TypeOffsets.resize(Index + 1); TypeOffsets[Index] = Stream.GetCurrentBitNo(); } RecordData Record; // Emit the type's representation. ASTTypeWriter W(*this, Record); W.AbbrevToUse = 0; if (T.hasLocalNonFastQualifiers()) { Qualifiers Qs = T.getLocalQualifiers(); AddTypeRef(T.getLocalUnqualifiedType(), Record); Record.push_back(Qs.getAsOpaqueValue()); W.Code = TYPE_EXT_QUAL; W.AbbrevToUse = TypeExtQualAbbrev; } else { switch (T->getTypeClass()) { // For all of the concrete, non-dependent types, call the // appropriate visitor function. #define TYPE(Class, Base) \ case Type::Class: W.Visit##Class##Type(cast(T)); break; #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" } } // Emit the serialized record. Stream.EmitRecord(W.Code, Record, W.AbbrevToUse); // Flush any expressions that were written as part of this type. FlushStmts(); } //===----------------------------------------------------------------------===// // Declaration Serialization //===----------------------------------------------------------------------===// /// \brief Write the block containing all of the declaration IDs /// lexically declared within the given DeclContext. /// /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the /// bistream, or 0 if no block was written. uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, DeclContext *DC) { if (DC->decls_empty()) return 0; uint64_t Offset = Stream.GetCurrentBitNo(); RecordData Record; Record.push_back(DECL_CONTEXT_LEXICAL); SmallVector Decls; for (const auto *D : DC->decls()) Decls.push_back(std::make_pair(D->getKind(), GetDeclRef(D))); ++NumLexicalDeclContexts; Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls)); return Offset; } void ASTWriter::WriteTypeDeclOffsets() { using namespace llvm; RecordData Record; // Write the type offsets array BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(TYPE_OFFSET); Record.push_back(TypeOffsets.size()); Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS); Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets)); // Write the declaration offsets array Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(DECL_OFFSET); Record.push_back(DeclOffsets.size()); Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS); Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets)); } void ASTWriter::WriteFileDeclIDsMap() { using namespace llvm; RecordData Record; // Join the vectors of DeclIDs from all files. SmallVector FileSortedIDs; for (FileDeclIDsTy::iterator FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) { DeclIDInFileInfo &Info = *FI->second; Info.FirstDeclIndex = FileSortedIDs.size(); for (LocDeclIDsTy::iterator DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI) FileSortedIDs.push_back(DI->second); } BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); Record.push_back(FILE_SORTED_DECLS); Record.push_back(FileSortedIDs.size()); Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs)); } void ASTWriter::WriteComments() { Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3); ArrayRef RawComments = Context->Comments.getComments(); RecordData Record; for (ArrayRef::iterator I = RawComments.begin(), E = RawComments.end(); I != E; ++I) { Record.clear(); AddSourceRange((*I)->getSourceRange(), Record); Record.push_back((*I)->getKind()); Record.push_back((*I)->isTrailingComment()); Record.push_back((*I)->isAlmostTrailingComment()); Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record); } Stream.ExitBlock(); } //===----------------------------------------------------------------------===// // Global Method Pool and Selector Serialization //===----------------------------------------------------------------------===// namespace { // Trait used for the on-disk hash table used in the method pool. class ASTMethodPoolTrait { ASTWriter &Writer; public: typedef Selector key_type; typedef key_type key_type_ref; struct data_type { SelectorID ID; ObjCMethodList Instance, Factory; }; typedef const data_type& data_type_ref; typedef unsigned hash_value_type; typedef unsigned offset_type; explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } static hash_value_type ComputeHash(Selector Sel) { return serialization::ComputeHash(Sel); } std::pair EmitKeyDataLength(raw_ostream& Out, Selector Sel, data_type_ref Methods) { using namespace llvm::support; endian::Writer LE(Out); unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); LE.write(KeyLen); unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) DataLen += 4; for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) DataLen += 4; LE.write(DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, Selector Sel, unsigned) { using namespace llvm::support; endian::Writer LE(Out); uint64_t Start = Out.tell(); assert((Start >> 32) == 0 && "Selector key offset too large"); Writer.SetSelectorOffset(Sel, Start); unsigned N = Sel.getNumArgs(); LE.write(N); if (N == 0) N = 1; for (unsigned I = 0; I != N; ++I) LE.write( Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); } void EmitData(raw_ostream& Out, key_type_ref, data_type_ref Methods, unsigned DataLen) { using namespace llvm::support; endian::Writer LE(Out); uint64_t Start = Out.tell(); (void)Start; LE.write(Methods.ID); unsigned NumInstanceMethods = 0; for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) ++NumInstanceMethods; unsigned NumFactoryMethods = 0; for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) ++NumFactoryMethods; unsigned InstanceBits = Methods.Instance.getBits(); assert(InstanceBits < 4); unsigned NumInstanceMethodsAndBits = (NumInstanceMethods << 2) | InstanceBits; unsigned FactoryBits = Methods.Factory.getBits(); assert(FactoryBits < 4); unsigned NumFactoryMethodsAndBits = (NumFactoryMethods << 2) | FactoryBits; LE.write(NumInstanceMethodsAndBits); LE.write(NumFactoryMethodsAndBits); for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) LE.write(Writer.getDeclID(Method->Method)); for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) LE.write(Writer.getDeclID(Method->Method)); assert(Out.tell() - Start == DataLen && "Data length is wrong"); } }; } // end anonymous namespace /// \brief Write ObjC data: selectors and the method pool. /// /// The method pool contains both instance and factory methods, stored /// in an on-disk hash table indexed by the selector. The hash table also /// contains an empty entry for every other selector known to Sema. void ASTWriter::WriteSelectors(Sema &SemaRef) { using namespace llvm; // Do we have to do anything at all? if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) return; unsigned NumTableEntries = 0; // Create and write out the blob that contains selectors and the method pool. { llvm::OnDiskChainedHashTableGenerator Generator; ASTMethodPoolTrait Trait(*this); // Create the on-disk hash table representation. We walk through every // selector we've seen and look it up in the method pool. SelectorOffsets.resize(NextSelectorID - FirstSelectorID); for (llvm::DenseMap::iterator I = SelectorIDs.begin(), E = SelectorIDs.end(); I != E; ++I) { Selector S = I->first; Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); ASTMethodPoolTrait::data_type Data = { I->second, ObjCMethodList(), ObjCMethodList() }; if (F != SemaRef.MethodPool.end()) { Data.Instance = F->second.first; Data.Factory = F->second.second; } // Only write this selector if it's not in an existing AST or something // changed. if (Chain && I->second < FirstSelectorID) { // Selector already exists. Did it change? bool changed = false; for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method; M = M->getNext()) { if (!M->Method->isFromASTFile()) changed = true; } for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method; M = M->getNext()) { if (!M->Method->isFromASTFile()) changed = true; } if (!changed) continue; } else if (Data.Instance.Method || Data.Factory.Method) { // A new method pool entry. ++NumTableEntries; } Generator.insert(S, Data, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> MethodPool; uint32_t BucketOffset; { using namespace llvm::support; ASTMethodPoolTrait Trait(*this); llvm::raw_svector_ostream Out(MethodPool); // Make sure that no bucket is at offset 0 endian::Writer(Out).write(0); BucketOffset = Generator.Emit(Out, Trait); } // Create a blob abbreviation BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); // Write the method pool RecordData Record; Record.push_back(METHOD_POOL); Record.push_back(BucketOffset); Record.push_back(NumTableEntries); Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str()); // Create a blob abbreviation for the selector table offsets. Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); // Write the selector offsets table. Record.clear(); Record.push_back(SELECTOR_OFFSETS); Record.push_back(SelectorOffsets.size()); Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS); Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, data(SelectorOffsets)); } } /// \brief Write the selectors referenced in @@selector expression into AST file. void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { using namespace llvm; if (SemaRef.ReferencedSelectors.empty()) return; RecordData Record; // Note: this writes out all references even for a dependent AST. But it is // very tricky to fix, and given that @@selector shouldn't really appear in // headers, probably not worth it. It's not a correctness issue. for (DenseMap::iterator S = SemaRef.ReferencedSelectors.begin(), E = SemaRef.ReferencedSelectors.end(); S != E; ++S) { Selector Sel = (*S).first; SourceLocation Loc = (*S).second; AddSelectorRef(Sel, Record); AddSourceLocation(Loc, Record); } Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record); } //===----------------------------------------------------------------------===// // Identifier Table Serialization //===----------------------------------------------------------------------===// namespace { class ASTIdentifierTableTrait { ASTWriter &Writer; Preprocessor &PP; IdentifierResolver &IdResolver; bool IsModule; /// \brief Determines whether this is an "interesting" identifier /// that needs a full IdentifierInfo structure written into the hash /// table. bool isInterestingIdentifier(IdentifierInfo *II, MacroDirective *&Macro) { if (II->isPoisoned() || II->isExtensionToken() || II->getObjCOrBuiltinID() || II->hasRevertedTokenIDToIdentifier() || II->getFETokenInfo()) return true; return hadMacroDefinition(II, Macro); } bool hadMacroDefinition(IdentifierInfo *II, MacroDirective *&Macro) { if (!II->hadMacroDefinition()) return false; if (Macro || (Macro = PP.getMacroDirectiveHistory(II))) { if (!IsModule) return !shouldIgnoreMacro(Macro, IsModule, PP); MacroState State; if (getFirstPublicSubmoduleMacro(Macro, State)) return true; } return false; } enum class SubmoduleMacroState { /// We've seen nothing about this macro. None, /// We've seen a public visibility directive. Public, /// We've either exported a macro for this module or found that the /// module's definition of this macro is private. Done }; typedef llvm::DenseMap MacroState; MacroDirective * getFirstPublicSubmoduleMacro(MacroDirective *MD, MacroState &State) { if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD, State)) return NextMD; return nullptr; } MacroDirective * getNextPublicSubmoduleMacro(MacroDirective *MD, MacroState &State) { if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD->getPrevious(), State)) return NextMD; return nullptr; } /// \brief Traverses the macro directives history and returns the next /// public macro definition or undefinition that has not been found so far. /// /// A macro that is defined in submodule A and undefined in submodule B /// will still be considered as defined/exported from submodule A. MacroDirective *getPublicSubmoduleMacro(MacroDirective *MD, MacroState &State) { if (!MD) return nullptr; Optional IsPublic; for (; MD; MD = MD->getPrevious()) { // Once we hit an ignored macro, we're done: the rest of the chain // will all be ignored macros. if (shouldIgnoreMacro(MD, IsModule, PP)) break; // If this macro was imported, re-export it. if (MD->isImported()) return MD; SubmoduleID ModID = getSubmoduleID(MD); auto &S = State[ModID]; assert(ModID && "found macro in no submodule"); if (S == SubmoduleMacroState::Done) continue; if (auto *VisMD = dyn_cast(MD)) { // The latest visibility directive for a name in a submodule affects all // the directives that come before it. if (S == SubmoduleMacroState::None) S = VisMD->isPublic() ? SubmoduleMacroState::Public : SubmoduleMacroState::Done; } else { S = SubmoduleMacroState::Done; return MD; } } return nullptr; } ArrayRef getOverriddenSubmodules(MacroDirective *MD, SmallVectorImpl &ScratchSpace) { assert(!isa(MD) && "only #define and #undef can override"); if (MD->isImported()) return MD->getOverriddenModules(); ScratchSpace.clear(); SubmoduleID ModID = getSubmoduleID(MD); for (MD = MD->getPrevious(); MD; MD = MD->getPrevious()) { if (shouldIgnoreMacro(MD, IsModule, PP)) break; // If this is a definition from a submodule import, that submodule's // definition is overridden by the definition or undefinition that we // started with. if (MD->isImported()) { if (auto *DefMD = dyn_cast(MD)) { SubmoduleID DefModuleID = DefMD->getInfo()->getOwningModuleID(); assert(DefModuleID && "imported macro has no owning module"); ScratchSpace.push_back(DefModuleID); } else if (auto *UndefMD = dyn_cast(MD)) { // If we override a #undef, we override anything that #undef overrides. // We don't need to override it, since an active #undef doesn't affect // the meaning of a macro. auto Overrides = UndefMD->getOverriddenModules(); ScratchSpace.insert(ScratchSpace.end(), Overrides.begin(), Overrides.end()); } } // Stop once we leave the original macro's submodule. // // Either this submodule #included another submodule of the same // module or it just happened to be built after the other module. // In the former case, we override the submodule's macro. // // FIXME: In the latter case, we shouldn't do so, but we can't tell // these cases apart. // // FIXME: We can leave this submodule and re-enter it if it #includes a // header within a different submodule of the same module. In such cases // the overrides list will be incomplete. SubmoduleID DirectiveModuleID = getSubmoduleID(MD); if (DirectiveModuleID != ModID) { if (DirectiveModuleID && !MD->isImported()) ScratchSpace.push_back(DirectiveModuleID); break; } } std::sort(ScratchSpace.begin(), ScratchSpace.end()); ScratchSpace.erase(std::unique(ScratchSpace.begin(), ScratchSpace.end()), ScratchSpace.end()); return ScratchSpace; } SubmoduleID getSubmoduleID(MacroDirective *MD) { return Writer.inferSubmoduleIDFromLocation(MD->getLocation()); } public: typedef IdentifierInfo* key_type; typedef key_type key_type_ref; typedef IdentID data_type; typedef data_type data_type_ref; typedef unsigned hash_value_type; typedef unsigned offset_type; ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, IdentifierResolver &IdResolver, bool IsModule) : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { } static hash_value_type ComputeHash(const IdentifierInfo* II) { return llvm::HashString(II->getName()); } std::pair EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { unsigned KeyLen = II->getLength() + 1; unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 MacroDirective *Macro = nullptr; if (isInterestingIdentifier(II, Macro)) { DataLen += 2; // 2 bytes for builtin ID DataLen += 2; // 2 bytes for flags if (hadMacroDefinition(II, Macro)) { DataLen += 4; // MacroDirectives offset. if (IsModule) { MacroState State; SmallVector Scratch; for (MacroDirective *MD = getFirstPublicSubmoduleMacro(Macro, State); MD; MD = getNextPublicSubmoduleMacro(MD, State)) { DataLen += 4; // MacroInfo ID or ModuleID. if (unsigned NumOverrides = getOverriddenSubmodules(MD, Scratch).size()) DataLen += 4 * (1 + NumOverrides); } DataLen += 4; // 0 terminator. } } for (IdentifierResolver::iterator D = IdResolver.begin(II), DEnd = IdResolver.end(); D != DEnd; ++D) DataLen += 4; } using namespace llvm::support; endian::Writer LE(Out); LE.write(DataLen); // We emit the key length after the data length so that every // string is preceded by a 16-bit length. This matches the PTH // format for storing identifiers. LE.write(KeyLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, const IdentifierInfo* II, unsigned KeyLen) { // Record the location of the key data. This is used when generating // the mapping from persistent IDs to strings. Writer.SetIdentifierOffset(II, Out.tell()); Out.write(II->getNameStart(), KeyLen); } static void emitMacroOverrides(raw_ostream &Out, ArrayRef Overridden) { if (!Overridden.empty()) { using namespace llvm::support; endian::Writer LE(Out); LE.write(Overridden.size() | 0x80000000U); for (unsigned I = 0, N = Overridden.size(); I != N; ++I) { assert(Overridden[I] && "zero module ID for override"); LE.write(Overridden[I]); } } } void EmitData(raw_ostream& Out, IdentifierInfo* II, IdentID ID, unsigned) { using namespace llvm::support; endian::Writer LE(Out); MacroDirective *Macro = nullptr; if (!isInterestingIdentifier(II, Macro)) { LE.write(ID << 1); return; } LE.write((ID << 1) | 0x01); uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID(); assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader."); LE.write(Bits); Bits = 0; bool HadMacroDefinition = hadMacroDefinition(II, Macro); Bits = (Bits << 1) | unsigned(HadMacroDefinition); Bits = (Bits << 1) | unsigned(IsModule); Bits = (Bits << 1) | unsigned(II->isExtensionToken()); Bits = (Bits << 1) | unsigned(II->isPoisoned()); Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); LE.write(Bits); if (HadMacroDefinition) { LE.write(Writer.getMacroDirectivesOffset(II)); if (IsModule) { // Write the IDs of macros coming from different submodules. MacroState State; SmallVector Scratch; for (MacroDirective *MD = getFirstPublicSubmoduleMacro(Macro, State); MD; MD = getNextPublicSubmoduleMacro(MD, State)) { if (DefMacroDirective *DefMD = dyn_cast(MD)) { // FIXME: If this macro directive was created by #pragma pop_macros, // or if it was created implicitly by resolving conflicting macros, // it may be for a different submodule from the one in the MacroInfo // object. If so, we should write out its owning ModuleID. MacroID InfoID = Writer.getMacroID(DefMD->getInfo()); assert(InfoID); LE.write(InfoID << 1); } else { auto *UndefMD = cast(MD); SubmoduleID Mod = UndefMD->isImported() ? UndefMD->getOwningModuleID() : getSubmoduleID(UndefMD); LE.write((Mod << 1) | 1); } emitMacroOverrides(Out, getOverriddenSubmodules(MD, Scratch)); } LE.write(0xdeadbeef); } } // Emit the declaration IDs in reverse order, because the // IdentifierResolver provides the declarations as they would be // visible (e.g., the function "stat" would come before the struct // "stat"), but the ASTReader adds declarations to the end of the list // (so we need to see the struct "status" before the function "status"). // Only emit declarations that aren't from a chained PCH, though. SmallVector Decls(IdResolver.begin(II), IdResolver.end()); for (SmallVectorImpl::reverse_iterator D = Decls.rbegin(), DEnd = Decls.rend(); D != DEnd; ++D) LE.write(Writer.getDeclID(getMostRecentLocalDecl(*D))); } /// \brief Returns the most recent local decl or the given decl if there are /// no local ones. The given decl is assumed to be the most recent one. Decl *getMostRecentLocalDecl(Decl *Orig) { // The only way a "from AST file" decl would be more recent from a local one // is if it came from a module. if (!PP.getLangOpts().Modules) return Orig; // Look for a local in the decl chain. for (Decl *D = Orig; D; D = D->getPreviousDecl()) { if (!D->isFromASTFile()) return D; // If we come up a decl from a (chained-)PCH stop since we won't find a // local one. if (D->getOwningModuleID() == 0) break; } return Orig; } }; } // end anonymous namespace /// \brief Write the identifier table into the AST file. /// /// The identifier table consists of a blob containing string data /// (the actual identifiers themselves) and a separate "offsets" index /// that maps identifier IDs to locations within the blob. void ASTWriter::WriteIdentifierTable(Preprocessor &PP, IdentifierResolver &IdResolver, bool IsModule) { using namespace llvm; // Create and write out the blob that contains the identifier // strings. { llvm::OnDiskChainedHashTableGenerator Generator; ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); // Look for any identifiers that were named while processing the // headers, but are otherwise not needed. We add these to the hash // table to enable checking of the predefines buffer in the case // where the user adds new macro definitions when building the AST // file. for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) getIdentifierRef(ID->second); // Create the on-disk hash table representation. We only store offsets // for identifiers that appear here for the first time. IdentifierOffsets.resize(NextIdentID - FirstIdentID); for (llvm::DenseMap::iterator ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); ID != IDEnd; ++ID) { assert(ID->first && "NULL identifier in identifier table"); if (!Chain || !ID->first->isFromAST() || ID->first->hasChangedSinceDeserialization()) Generator.insert(const_cast(ID->first), ID->second, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> IdentifierTable; uint32_t BucketOffset; { using namespace llvm::support; ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); llvm::raw_svector_ostream Out(IdentifierTable); // Make sure that no bucket is at offset 0 endian::Writer(Out).write(0); BucketOffset = Generator.Emit(Out, Trait); } // Create a blob abbreviation BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); // Write the identifier table RecordData Record; Record.push_back(IDENTIFIER_TABLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str()); } // Write the offsets table for identifier IDs. BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); #ifndef NDEBUG for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I) assert(IdentifierOffsets[I] && "Missing identifier offset?"); #endif RecordData Record; Record.push_back(IDENTIFIER_OFFSET); Record.push_back(IdentifierOffsets.size()); Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS); Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, data(IdentifierOffsets)); } //===----------------------------------------------------------------------===// // DeclContext's Name Lookup Table Serialization //===----------------------------------------------------------------------===// namespace { // Trait used for the on-disk hash table used in the method pool. class ASTDeclContextNameLookupTrait { ASTWriter &Writer; public: typedef DeclarationName key_type; typedef key_type key_type_ref; typedef DeclContext::lookup_result data_type; typedef const data_type& data_type_ref; typedef unsigned hash_value_type; typedef unsigned offset_type; explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { } hash_value_type ComputeHash(DeclarationName Name) { llvm::FoldingSetNodeID ID; ID.AddInteger(Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: ID.AddString(Name.getAsIdentifierInfo()->getName()); break; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector())); break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: break; case DeclarationName::CXXOperatorName: ID.AddInteger(Name.getCXXOverloadedOperator()); break; case DeclarationName::CXXLiteralOperatorName: ID.AddString(Name.getCXXLiteralIdentifier()->getName()); case DeclarationName::CXXUsingDirective: break; } return ID.ComputeHash(); } std::pair EmitKeyDataLength(raw_ostream& Out, DeclarationName Name, data_type_ref Lookup) { using namespace llvm::support; endian::Writer LE(Out); unsigned KeyLen = 1; switch (Name.getNameKind()) { case DeclarationName::Identifier: case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: case DeclarationName::CXXLiteralOperatorName: KeyLen += 4; break; case DeclarationName::CXXOperatorName: KeyLen += 1; break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: case DeclarationName::CXXUsingDirective: break; } LE.write(KeyLen); // 2 bytes for num of decls and 4 for each DeclID. unsigned DataLen = 2 + 4 * Lookup.size(); LE.write(DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) { using namespace llvm::support; endian::Writer LE(Out); LE.write(Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: LE.write(Writer.getIdentifierRef(Name.getAsIdentifierInfo())); return; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: LE.write(Writer.getSelectorRef(Name.getObjCSelector())); return; case DeclarationName::CXXOperatorName: assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS && "Invalid operator?"); LE.write(Name.getCXXOverloadedOperator()); return; case DeclarationName::CXXLiteralOperatorName: LE.write(Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); return; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: case DeclarationName::CXXUsingDirective: return; } llvm_unreachable("Invalid name kind?"); } void EmitData(raw_ostream& Out, key_type_ref, data_type Lookup, unsigned DataLen) { using namespace llvm::support; endian::Writer LE(Out); uint64_t Start = Out.tell(); (void)Start; LE.write(Lookup.size()); for (DeclContext::lookup_iterator I = Lookup.begin(), E = Lookup.end(); I != E; ++I) LE.write(Writer.GetDeclRef(*I)); assert(Out.tell() - Start == DataLen && "Data length is wrong"); } }; } // end anonymous namespace template static void visitLocalLookupResults(const DeclContext *ConstDC, bool NeedToReconcileExternalVisibleStorage, Visitor AddLookupResult) { // FIXME: We need to build the lookups table, which is logically const. DeclContext *DC = const_cast(ConstDC); assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table"); SmallVector ExternalNames; for (auto &Lookup : *DC->buildLookup()) { if (Lookup.second.hasExternalDecls() || NeedToReconcileExternalVisibleStorage) { // We don't know for sure what declarations are found by this name, // because the external source might have a different set from the set // that are in the lookup map, and we can't update it now without // risking invalidating our lookup iterator. So add it to a queue to // deal with later. ExternalNames.push_back(Lookup.first); continue; } AddLookupResult(Lookup.first, Lookup.second.getLookupResult()); } // Add the names we needed to defer. Note, this shouldn't add any new decls // to the list we need to serialize: any new declarations we find here should // be imported from an external source. // FIXME: What if the external source isn't an ASTReader? for (const auto &Name : ExternalNames) AddLookupResult(Name, DC->lookup(Name)); } void ASTWriter::AddUpdatedDeclContext(const DeclContext *DC) { if (UpdatedDeclContexts.insert(DC) && WritingAST) { // Ensure we emit all the visible declarations. visitLocalLookupResults(DC, DC->NeedToReconcileExternalVisibleStorage, [&](DeclarationName Name, DeclContext::lookup_const_result Result) { for (auto *Decl : Result) GetDeclRef(Decl); }); } } uint32_t ASTWriter::GenerateNameLookupTable(const DeclContext *DC, llvm::SmallVectorImpl &LookupTable) { assert(!DC->LookupPtr.getInt() && "must call buildLookups first"); llvm::OnDiskChainedHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // Create the on-disk hash table representation. DeclarationName ConstructorName; DeclarationName ConversionName; SmallVector ConstructorDecls; SmallVector ConversionDecls; visitLocalLookupResults(DC, DC->NeedToReconcileExternalVisibleStorage, [&](DeclarationName Name, DeclContext::lookup_result Result) { if (Result.empty()) return; // Different DeclarationName values of certain kinds are mapped to // identical serialized keys, because we don't want to use type // identifiers in the keys (since type ids are local to the module). switch (Name.getNameKind()) { case DeclarationName::CXXConstructorName: // There may be different CXXConstructorName DeclarationName values // in a DeclContext because a UsingDecl that inherits constructors // has the DeclarationName of the inherited constructors. if (!ConstructorName) ConstructorName = Name; ConstructorDecls.append(Result.begin(), Result.end()); return; case DeclarationName::CXXConversionFunctionName: if (!ConversionName) ConversionName = Name; ConversionDecls.append(Result.begin(), Result.end()); return; default: break; } Generator.insert(Name, Result, Trait); }); // Add the constructors. if (!ConstructorDecls.empty()) { Generator.insert(ConstructorName, DeclContext::lookup_result(ConstructorDecls.begin(), ConstructorDecls.end()), Trait); } // Add the conversion functions. if (!ConversionDecls.empty()) { Generator.insert(ConversionName, DeclContext::lookup_result(ConversionDecls.begin(), ConversionDecls.end()), Trait); } // Create the on-disk hash table in a buffer. llvm::raw_svector_ostream Out(LookupTable); // Make sure that no bucket is at offset 0 using namespace llvm::support; endian::Writer(Out).write(0); return Generator.Emit(Out, Trait); } /// \brief Write the block containing all of the declaration IDs /// visible from the given DeclContext. /// /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the /// bitstream, or 0 if no block was written. uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC) { if (DC->getPrimaryContext() != DC) return 0; // Since there is no name lookup into functions or methods, don't bother to // build a visible-declarations table for these entities. if (DC->isFunctionOrMethod()) return 0; // If not in C++, we perform name lookup for the translation unit via the // IdentifierInfo chains, don't bother to build a visible-declarations table. if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus) return 0; // Serialize the contents of the mapping used for lookup. Note that, // although we have two very different code paths, the serialized // representation is the same for both cases: a declaration name, // followed by a size, followed by references to the visible // declarations that have that name. uint64_t Offset = Stream.GetCurrentBitNo(); StoredDeclsMap *Map = DC->buildLookup(); if (!Map || Map->empty()) return 0; // Create the on-disk hash table in a buffer. SmallString<4096> LookupTable; uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable); // Write the lookup table RecordData Record; Record.push_back(DECL_CONTEXT_VISIBLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, LookupTable.str()); ++NumVisibleDeclContexts; return Offset; } /// \brief Write an UPDATE_VISIBLE block for the given context. /// /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing /// DeclContext in a dependent AST file. As such, they only exist for the TU /// (in C++), for namespaces, and for classes with forward-declared unscoped /// enumeration members (in C++11). void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { StoredDeclsMap *Map = DC->getLookupPtr(); if (!Map || Map->empty()) return; // Create the on-disk hash table in a buffer. SmallString<4096> LookupTable; uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable); // Write the lookup table RecordData Record; Record.push_back(UPDATE_VISIBLE); Record.push_back(getDeclID(cast(DC))); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str()); } /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { RecordData Record; Record.push_back(Opts.fp_contract); Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); } /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { if (!SemaRef.Context.getLangOpts().OpenCL) return; const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); RecordData Record; #define OPENCLEXT(nm) Record.push_back(Opts.nm); #include "clang/Basic/OpenCLExtensions.def" Stream.EmitRecord(OPENCL_EXTENSIONS, Record); } void ASTWriter::WriteRedeclarations() { RecordData LocalRedeclChains; SmallVector LocalRedeclsMap; for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) { Decl *First = Redeclarations[I]; assert(First->isFirstDecl() && "Not the first declaration?"); Decl *MostRecent = First->getMostRecentDecl(); // If we only have a single declaration, there is no point in storing // a redeclaration chain. if (First == MostRecent) continue; unsigned Offset = LocalRedeclChains.size(); unsigned Size = 0; LocalRedeclChains.push_back(0); // Placeholder for the size. // Collect the set of local redeclarations of this declaration. for (Decl *Prev = MostRecent; Prev != First; Prev = Prev->getPreviousDecl()) { if (!Prev->isFromASTFile()) { AddDeclRef(Prev, LocalRedeclChains); ++Size; } } if (!First->isFromASTFile() && Chain) { Decl *FirstFromAST = MostRecent; for (Decl *Prev = MostRecent; Prev; Prev = Prev->getPreviousDecl()) { if (Prev->isFromASTFile()) FirstFromAST = Prev; } Chain->MergedDecls[FirstFromAST].push_back(getDeclID(First)); } LocalRedeclChains[Offset] = Size; // Reverse the set of local redeclarations, so that we store them in // order (since we found them in reverse order). std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end()); // Add the mapping from the first ID from the AST to the set of local // declarations. LocalRedeclarationsInfo Info = { getDeclID(First), Offset }; LocalRedeclsMap.push_back(Info); assert(N == Redeclarations.size() && "Deserialized a declaration we shouldn't have"); } if (LocalRedeclChains.empty()) return; // Sort the local redeclarations map by the first declaration ID, // since the reader will be performing binary searches on this information. llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end()); // Emit the local redeclarations map. using namespace llvm; llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(LOCAL_REDECLARATIONS_MAP); Record.push_back(LocalRedeclsMap.size()); Stream.EmitRecordWithBlob(AbbrevID, Record, reinterpret_cast(LocalRedeclsMap.data()), LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo)); // Emit the redeclaration chains. Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains); } void ASTWriter::WriteObjCCategories() { SmallVector CategoriesMap; RecordData Categories; for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) { unsigned Size = 0; unsigned StartIndex = Categories.size(); ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I]; // Allocate space for the size. Categories.push_back(0); // Add the categories. for (ObjCInterfaceDecl::known_categories_iterator Cat = Class->known_categories_begin(), CatEnd = Class->known_categories_end(); Cat != CatEnd; ++Cat, ++Size) { assert(getDeclID(*Cat) != 0 && "Bogus category"); AddDeclRef(*Cat, Categories); } // Update the size. Categories[StartIndex] = Size; // Record this interface -> category map. ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex }; CategoriesMap.push_back(CatInfo); } // Sort the categories map by the definition ID, since the reader will be // performing binary searches on this information. llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end()); // Emit the categories map. using namespace llvm; llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(OBJC_CATEGORIES_MAP); Record.push_back(CategoriesMap.size()); Stream.EmitRecordWithBlob(AbbrevID, Record, reinterpret_cast(CategoriesMap.data()), CategoriesMap.size() * sizeof(ObjCCategoriesInfo)); // Emit the category lists. Stream.EmitRecord(OBJC_CATEGORIES, Categories); } void ASTWriter::WriteMergedDecls() { if (!Chain || Chain->MergedDecls.empty()) return; RecordData Record; for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(), IEnd = Chain->MergedDecls.end(); I != IEnd; ++I) { DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID() : GetDeclRef(I->first); assert(CanonID && "Merged declaration not known?"); Record.push_back(CanonID); Record.push_back(I->second.size()); Record.append(I->second.begin(), I->second.end()); } Stream.EmitRecord(MERGED_DECLARATIONS, Record); } void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) { Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap; if (LPTMap.empty()) return; RecordData Record; for (Sema::LateParsedTemplateMapT::iterator It = LPTMap.begin(), ItEnd = LPTMap.end(); It != ItEnd; ++It) { LateParsedTemplate *LPT = It->second; AddDeclRef(It->first, Record); AddDeclRef(LPT->D, Record); Record.push_back(LPT->Toks.size()); for (CachedTokens::iterator TokIt = LPT->Toks.begin(), TokEnd = LPT->Toks.end(); TokIt != TokEnd; ++TokIt) { AddToken(*TokIt, Record); } } Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record); } /// \brief Write the state of 'pragma clang optimize' at the end of the module. void ASTWriter::WriteOptimizePragmaOptions(Sema &SemaRef) { RecordData Record; SourceLocation PragmaLoc = SemaRef.getOptimizeOffPragmaLocation(); AddSourceLocation(PragmaLoc, Record); Stream.EmitRecord(OPTIMIZE_PRAGMA_OPTIONS, Record); } //===----------------------------------------------------------------------===// // General Serialization Routines //===----------------------------------------------------------------------===// /// \brief Write a record containing the given attributes. void ASTWriter::WriteAttributes(ArrayRef Attrs, RecordDataImpl &Record) { Record.push_back(Attrs.size()); for (ArrayRef::iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){ const Attr *A = *i; Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs AddSourceRange(A->getRange(), Record); #include "clang/Serialization/AttrPCHWrite.inc" } } void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) { AddSourceLocation(Tok.getLocation(), Record); Record.push_back(Tok.getLength()); // FIXME: When reading literal tokens, reconstruct the literal pointer // if it is needed. AddIdentifierRef(Tok.getIdentifierInfo(), Record); // FIXME: Should translate token kind to a stable encoding. Record.push_back(Tok.getKind()); // FIXME: Should translate token flags to a stable encoding. Record.push_back(Tok.getFlags()); } void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { Record.push_back(Str.size()); Record.insert(Record.end(), Str.begin(), Str.end()); } void ASTWriter::AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record) { Record.push_back(Version.getMajor()); if (Optional Minor = Version.getMinor()) Record.push_back(*Minor + 1); else Record.push_back(0); if (Optional Subminor = Version.getSubminor()) Record.push_back(*Subminor + 1); else Record.push_back(0); } /// \brief Note that the identifier II occurs at the given offset /// within the identifier table. void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { IdentID ID = IdentifierIDs[II]; // Only store offsets new to this AST file. Other identifier names are looked // up earlier in the chain and thus don't need an offset. if (ID >= FirstIdentID) IdentifierOffsets[ID - FirstIdentID] = Offset; } /// \brief Note that the selector Sel occurs at the given offset /// within the method pool/selector table. void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { unsigned ID = SelectorIDs[Sel]; assert(ID && "Unknown selector"); // Don't record offsets for selectors that are also available in a different // file. if (ID < FirstSelectorID) return; SelectorOffsets[ID - FirstSelectorID] = Offset; } ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) : Stream(Stream), Context(nullptr), PP(nullptr), Chain(nullptr), WritingModule(nullptr), WritingAST(false), DoneWritingDeclsAndTypes(false), ASTHasCompilerErrors(false), FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID), FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), NextSubmoduleID(FirstSubmoduleID), FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), NumVisibleDeclContexts(0), NextCXXBaseSpecifiersID(1), TypeExtQualAbbrev(0), TypeFunctionProtoAbbrev(0), DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0), DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0), DeclRecordAbbrev(0), DeclTypedefAbbrev(0), DeclVarAbbrev(0), DeclFieldAbbrev(0), DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0), DeclCXXMethodAbbrev(0), DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0), IntegerLiteralAbbrev(0), ExprImplicitCastAbbrev(0) {} ASTWriter::~ASTWriter() { llvm::DeleteContainerSeconds(FileDeclIDs); } void ASTWriter::WriteAST(Sema &SemaRef, const std::string &OutputFile, Module *WritingModule, StringRef isysroot, bool hasErrors) { WritingAST = true; ASTHasCompilerErrors = hasErrors; // Emit the file header. Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'P', 8); Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'H', 8); WriteBlockInfoBlock(); Context = &SemaRef.Context; PP = &SemaRef.PP; this->WritingModule = WritingModule; WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule); Context = nullptr; PP = nullptr; this->WritingModule = nullptr; WritingAST = false; } template static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, ASTWriter::RecordData &Record) { for (typename Vector::iterator I = Vec.begin(nullptr, true), E = Vec.end(); I != E; ++I) { Writer.AddDeclRef(*I, Record); } } void ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, const std::string &OutputFile, Module *WritingModule) { using namespace llvm; bool isModule = WritingModule != nullptr; // Make sure that the AST reader knows to finalize itself. if (Chain) Chain->finalizeForWriting(); ASTContext &Context = SemaRef.Context; Preprocessor &PP = SemaRef.PP; // Set up predefined declaration IDs. DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID; if (Context.ObjCIdDecl) DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID; if (Context.ObjCSelDecl) DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID; if (Context.ObjCClassDecl) DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID; if (Context.ObjCProtocolClassDecl) DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID; if (Context.Int128Decl) DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID; if (Context.UInt128Decl) DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID; if (Context.ObjCInstanceTypeDecl) DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID; if (Context.BuiltinVaListDecl) DeclIDs[Context.getBuiltinVaListDecl()] = PREDEF_DECL_BUILTIN_VA_LIST_ID; if (!Chain) { // Make sure that we emit IdentifierInfos (and any attached // declarations) for builtins. We don't need to do this when we're // emitting chained PCH files, because all of the builtins will be // in the original PCH file. // FIXME: Modules won't like this at all. IdentifierTable &Table = PP.getIdentifierTable(); SmallVector BuiltinNames; if (!Context.getLangOpts().NoBuiltin) { Context.BuiltinInfo.GetBuiltinNames(BuiltinNames); } for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) getIdentifierRef(&Table.get(BuiltinNames[I])); } // If there are any out-of-date identifiers, bring them up to date. if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) { // Find out-of-date identifiers. SmallVector OutOfDate; for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) { if (ID->second->isOutOfDate()) OutOfDate.push_back(ID->second); } // Update the out-of-date identifiers. for (unsigned I = 0, N = OutOfDate.size(); I != N; ++I) { ExtSource->updateOutOfDateIdentifier(*OutOfDate[I]); } } // If we saw any DeclContext updates before we started writing the AST file, // make sure all visible decls in those DeclContexts are written out. if (!UpdatedDeclContexts.empty()) { auto OldUpdatedDeclContexts = std::move(UpdatedDeclContexts); UpdatedDeclContexts.clear(); for (auto *DC : OldUpdatedDeclContexts) AddUpdatedDeclContext(DC); } // Build a record containing all of the tentative definitions in this file, in // TentativeDefinitions order. Generally, this record will be empty for // headers. RecordData TentativeDefinitions; AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions); // Build a record containing all of the file scoped decls in this file. RecordData UnusedFileScopedDecls; if (!isModule) AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls, UnusedFileScopedDecls); // Build a record containing all of the delegating constructors we still need // to resolve. RecordData DelegatingCtorDecls; if (!isModule) AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls); // Write the set of weak, undeclared identifiers. We always write the // entire table, since later PCH files in a PCH chain are only interested in // the results at the end of the chain. RecordData WeakUndeclaredIdentifiers; if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { for (llvm::DenseMap::iterator I = SemaRef.WeakUndeclaredIdentifiers.begin(), E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); } } // Build a record containing all of the locally-scoped extern "C" // declarations in this header file. Generally, this record will be // empty. RecordData LocallyScopedExternCDecls; // FIXME: This is filling in the AST file in densemap order which is // nondeterminstic! for (llvm::DenseMap::iterator TD = SemaRef.LocallyScopedExternCDecls.begin(), TDEnd = SemaRef.LocallyScopedExternCDecls.end(); TD != TDEnd; ++TD) { if (!TD->second->isFromASTFile()) AddDeclRef(TD->second, LocallyScopedExternCDecls); } // Build a record containing all of the ext_vector declarations. RecordData ExtVectorDecls; AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls); // Build a record containing all of the VTable uses information. RecordData VTableUses; if (!SemaRef.VTableUses.empty()) { for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); } } // Build a record containing all of dynamic classes declarations. RecordData DynamicClasses; AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses); // Build a record containing all of pending implicit instantiations. RecordData PendingInstantiations; for (std::deque::iterator I = SemaRef.PendingInstantiations.begin(), N = SemaRef.PendingInstantiations.end(); I != N; ++I) { AddDeclRef(I->first, PendingInstantiations); AddSourceLocation(I->second, PendingInstantiations); } assert(SemaRef.PendingLocalImplicitInstantiations.empty() && "There are local ones at end of translation unit!"); // Build a record containing some declaration references. RecordData SemaDeclRefs; if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); } RecordData CUDASpecialDeclRefs; if (Context.getcudaConfigureCallDecl()) { AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); } // Build a record containing all of the known namespaces. RecordData KnownNamespaces; for (llvm::MapVector::iterator I = SemaRef.KnownNamespaces.begin(), IEnd = SemaRef.KnownNamespaces.end(); I != IEnd; ++I) { if (!I->second) AddDeclRef(I->first, KnownNamespaces); } // Build a record of all used, undefined objects that require definitions. RecordData UndefinedButUsed; SmallVector, 16> Undefined; SemaRef.getUndefinedButUsed(Undefined); for (SmallVectorImpl >::iterator I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { AddDeclRef(I->first, UndefinedButUsed); AddSourceLocation(I->second, UndefinedButUsed); } // Write the control block WriteControlBlock(PP, Context, isysroot, OutputFile); // Write the remaining AST contents. RecordData Record; Stream.EnterSubblock(AST_BLOCK_ID, 5); // This is so that older clang versions, before the introduction // of the control block, can read and reject the newer PCH format. Record.clear(); Record.push_back(VERSION_MAJOR); Stream.EmitRecord(METADATA_OLD_FORMAT, Record); // Create a lexical update block containing all of the declarations in the // translation unit that do not come from other AST files. const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); SmallVector NewGlobalDecls; for (const auto *I : TU->noload_decls()) { if (!I->isFromASTFile()) NewGlobalDecls.push_back(std::make_pair(I->getKind(), GetDeclRef(I))); } llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); Record.clear(); Record.push_back(TU_UPDATE_LEXICAL); Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, data(NewGlobalDecls)); // And a visible updates block for the translation unit. Abv = new llvm::BitCodeAbbrev(); Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv); WriteDeclContextVisibleUpdate(TU); // If the translation unit has an anonymous namespace, and we don't already // have an update block for it, write it as an update block. // FIXME: Why do we not do this if there's already an update block? if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; if (Record.empty()) Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS)); } // Add update records for all mangling numbers and static local numbers. // These aren't really update records, but this is a convenient way of // tagging this rare extra data onto the declarations. for (const auto &Number : Context.MangleNumbers) if (!Number.first->isFromASTFile()) DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER, Number.second)); for (const auto &Number : Context.StaticLocalNumbers) if (!Number.first->isFromASTFile()) DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER, Number.second)); // Make sure visible decls, added to DeclContexts previously loaded from // an AST file, are registered for serialization. for (SmallVectorImpl::iterator I = UpdatingVisibleDecls.begin(), E = UpdatingVisibleDecls.end(); I != E; ++I) { GetDeclRef(*I); } // Make sure all decls associated with an identifier are registered for // serialization. for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) { const IdentifierInfo *II = ID->second; if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) { for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), DEnd = SemaRef.IdResolver.end(); D != DEnd; ++D) { GetDeclRef(*D); } } } // Form the record of special types. RecordData SpecialTypes; AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); AddTypeRef(Context.getFILEType(), SpecialTypes); AddTypeRef(Context.getjmp_bufType(), SpecialTypes); AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes); AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes); AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); AddTypeRef(Context.getucontext_tType(), SpecialTypes); if (Chain) { // Write the mapping information describing our module dependencies and how // each of those modules were mapped into our own offset/ID space, so that // the reader can build the appropriate mapping to its own offset/ID space. // The map consists solely of a blob with the following format: // *(module-name-len:i16 module-name:len*i8 // source-location-offset:i32 // identifier-id:i32 // preprocessed-entity-id:i32 // macro-definition-id:i32 // submodule-id:i32 // selector-id:i32 // declaration-id:i32 // c++-base-specifiers-id:i32 // type-id:i32) // llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); SmallString<2048> Buffer; { llvm::raw_svector_ostream Out(Buffer); for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), MEnd = Chain->ModuleMgr.end(); M != MEnd; ++M) { using namespace llvm::support; endian::Writer LE(Out); StringRef FileName = (*M)->FileName; LE.write(FileName.size()); Out.write(FileName.data(), FileName.size()); LE.write((*M)->SLocEntryBaseOffset); LE.write((*M)->BaseIdentifierID); LE.write((*M)->BaseMacroID); LE.write((*M)->BasePreprocessedEntityID); LE.write((*M)->BaseSubmoduleID); LE.write((*M)->BaseSelectorID); LE.write((*M)->BaseDeclID); LE.write((*M)->BaseTypeIndex); } } Record.clear(); Record.push_back(MODULE_OFFSET_MAP); Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, Buffer.data(), Buffer.size()); } RecordData DeclUpdatesOffsetsRecord; // Keep writing types, declarations, and declaration update records // until we've emitted all of them. Stream.EnterSubblock(DECLTYPES_BLOCK_ID, /*bits for abbreviations*/5); WriteTypeAbbrevs(); WriteDeclAbbrevs(); for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(), E = DeclsToRewrite.end(); I != E; ++I) DeclTypesToEmit.push(const_cast(*I)); do { WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord); while (!DeclTypesToEmit.empty()) { DeclOrType DOT = DeclTypesToEmit.front(); DeclTypesToEmit.pop(); if (DOT.isType()) WriteType(DOT.getType()); else WriteDecl(Context, DOT.getDecl()); } } while (!DeclUpdates.empty()); Stream.ExitBlock(); DoneWritingDeclsAndTypes = true; // These things can only be done once we've written out decls and types. WriteTypeDeclOffsets(); if (!DeclUpdatesOffsetsRecord.empty()) Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord); WriteCXXBaseSpecifiersOffsets(); WriteFileDeclIDsMap(); WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); WriteComments(); WritePreprocessor(PP, isModule); WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot); WriteSelectors(SemaRef); WriteReferencedSelectorsPool(SemaRef); WriteIdentifierTable(PP, SemaRef.IdResolver, isModule); WriteFPPragmaOptions(SemaRef.getFPOptions()); WriteOpenCLExtensions(SemaRef); WritePragmaDiagnosticMappings(Context.getDiagnostics(), isModule); // If we're emitting a module, write out the submodule information. if (WritingModule) WriteSubmodules(WritingModule); Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); // Write the record containing external, unnamed definitions. if (!EagerlyDeserializedDecls.empty()) Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls); // Write the record containing tentative definitions. if (!TentativeDefinitions.empty()) Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); // Write the record containing unused file scoped decls. if (!UnusedFileScopedDecls.empty()) Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); // Write the record containing weak undeclared identifiers. if (!WeakUndeclaredIdentifiers.empty()) Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, WeakUndeclaredIdentifiers); // Write the record containing locally-scoped extern "C" definitions. if (!LocallyScopedExternCDecls.empty()) Stream.EmitRecord(LOCALLY_SCOPED_EXTERN_C_DECLS, LocallyScopedExternCDecls); // Write the record containing ext_vector type names. if (!ExtVectorDecls.empty()) Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); // Write the record containing VTable uses information. if (!VTableUses.empty()) Stream.EmitRecord(VTABLE_USES, VTableUses); // Write the record containing dynamic classes declarations. if (!DynamicClasses.empty()) Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); // Write the record containing pending implicit instantiations. if (!PendingInstantiations.empty()) Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); // Write the record containing declaration references of Sema. if (!SemaDeclRefs.empty()) Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); // Write the record containing CUDA-specific declaration references. if (!CUDASpecialDeclRefs.empty()) Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); // Write the delegating constructors. if (!DelegatingCtorDecls.empty()) Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls); // Write the known namespaces. if (!KnownNamespaces.empty()) Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces); // Write the undefined internal functions and variables, and inline functions. if (!UndefinedButUsed.empty()) Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed); // Write the visible updates to DeclContexts. for (auto *DC : UpdatedDeclContexts) WriteDeclContextVisibleUpdate(DC); if (!WritingModule) { // Write the submodules that were imported, if any. struct ModuleInfo { uint64_t ID; Module *M; ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {} }; llvm::SmallVector Imports; for (const auto *I : Context.local_imports()) { assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()], I->getImportedModule())); } if (!Imports.empty()) { auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) { return A.ID < B.ID; }; // Sort and deduplicate module IDs. std::sort(Imports.begin(), Imports.end(), Cmp); Imports.erase(std::unique(Imports.begin(), Imports.end(), Cmp), Imports.end()); RecordData ImportedModules; for (const auto &Import : Imports) { ImportedModules.push_back(Import.ID); // FIXME: If the module has macros imported then later has declarations // imported, this location won't be the right one as a location for the // declaration imports. AddSourceLocation(Import.M->MacroVisibilityLoc, ImportedModules); } Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); } } WriteDeclReplacementsBlock(); WriteRedeclarations(); WriteMergedDecls(); WriteObjCCategories(); WriteLateParsedTemplates(SemaRef); if(!WritingModule) WriteOptimizePragmaOptions(SemaRef); // Some simple statistics Record.clear(); Record.push_back(NumStatements); Record.push_back(NumMacros); Record.push_back(NumLexicalDeclContexts); Record.push_back(NumVisibleDeclContexts); Stream.EmitRecord(STATISTICS, Record); Stream.ExitBlock(); } void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { if (DeclUpdates.empty()) return; DeclUpdateMap LocalUpdates; LocalUpdates.swap(DeclUpdates); for (auto &DeclUpdate : LocalUpdates) { const Decl *D = DeclUpdate.first; if (isRewritten(D)) continue; // The decl will be written completely,no need to store updates. bool HasUpdatedBody = false; RecordData Record; for (auto &Update : DeclUpdate.second) { DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind(); Record.push_back(Kind); switch (Kind) { case UPD_CXX_ADDED_IMPLICIT_MEMBER: case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: assert(Update.getDecl() && "no decl to add?"); Record.push_back(GetDeclRef(Update.getDecl())); break; case UPD_CXX_ADDED_FUNCTION_DEFINITION: // An updated body is emitted last, so that the reader doesn't need // to skip over the lazy body to reach statements for other records. Record.pop_back(); HasUpdatedBody = true; break; case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: AddSourceLocation(Update.getLoc(), Record); break; case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: { auto *RD = cast(D); AddUpdatedDeclContext(RD->getPrimaryContext()); AddCXXDefinitionData(RD, Record); Record.push_back(WriteDeclContextLexicalBlock( *Context, const_cast(RD))); // This state is sometimes updated by template instantiation, when we // switch from the specialization referring to the template declaration // to it referring to the template definition. if (auto *MSInfo = RD->getMemberSpecializationInfo()) { Record.push_back(MSInfo->getTemplateSpecializationKind()); AddSourceLocation(MSInfo->getPointOfInstantiation(), Record); } else { auto *Spec = cast(RD); Record.push_back(Spec->getTemplateSpecializationKind()); AddSourceLocation(Spec->getPointOfInstantiation(), Record); // The instantiation might have been resolved to a partial // specialization. If so, record which one. auto From = Spec->getInstantiatedFrom(); if (auto PartialSpec = From.dyn_cast()) { Record.push_back(true); AddDeclRef(PartialSpec, Record); AddTemplateArgumentList(&Spec->getTemplateInstantiationArgs(), Record); } else { Record.push_back(false); } } Record.push_back(RD->getTagKind()); AddSourceLocation(RD->getLocation(), Record); AddSourceLocation(RD->getLocStart(), Record); AddSourceLocation(RD->getRBraceLoc(), Record); // Instantiation may change attributes; write them all out afresh. Record.push_back(D->hasAttrs()); if (Record.back()) WriteAttributes(ArrayRef(D->getAttrs().begin(), D->getAttrs().size()), Record); // FIXME: Ensure we don't get here for explicit instantiations. break; } case UPD_CXX_RESOLVED_EXCEPTION_SPEC: addExceptionSpec( *this, cast(D)->getType()->castAs(), Record); break; case UPD_CXX_DEDUCED_RETURN_TYPE: Record.push_back(GetOrCreateTypeID(Update.getType())); break; case UPD_DECL_MARKED_USED: break; case UPD_MANGLING_NUMBER: case UPD_STATIC_LOCAL_NUMBER: Record.push_back(Update.getNumber()); break; } } if (HasUpdatedBody) { const FunctionDecl *Def = cast(D); Record.push_back(UPD_CXX_ADDED_FUNCTION_DEFINITION); Record.push_back(Def->isInlined()); AddSourceLocation(Def->getInnerLocStart(), Record); AddFunctionDefinition(Def, Record); if (auto *DD = dyn_cast(Def)) Record.push_back(GetDeclRef(DD->getOperatorDelete())); } OffsetsRecord.push_back(GetDeclRef(D)); OffsetsRecord.push_back(Stream.GetCurrentBitNo()); Stream.EmitRecord(DECL_UPDATES, Record); // Flush any statements that were written as part of this update record. FlushStmts(); // Flush C++ base specifiers, if there are any. FlushCXXBaseSpecifiers(); } } void ASTWriter::WriteDeclReplacementsBlock() { if (ReplacedDecls.empty()) return; RecordData Record; for (SmallVectorImpl::iterator I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { Record.push_back(I->ID); Record.push_back(I->Offset); Record.push_back(I->Loc); } Stream.EmitRecord(DECL_REPLACEMENTS, Record); } void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { Record.push_back(Loc.getRawEncoding()); } void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { AddSourceLocation(Range.getBegin(), Record); AddSourceLocation(Range.getEnd(), Record); } void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) { Record.push_back(Value.getBitWidth()); const uint64_t *Words = Value.getRawData(); Record.append(Words, Words + Value.getNumWords()); } void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) { Record.push_back(Value.isUnsigned()); AddAPInt(Value, Record); } void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) { AddAPInt(Value.bitcastToAPInt(), Record); } void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { Record.push_back(getIdentifierRef(II)); } IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { if (!II) return 0; IdentID &ID = IdentifierIDs[II]; if (ID == 0) ID = NextIdentID++; return ID; } MacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) { // Don't emit builtin macros like __LINE__ to the AST file unless they // have been redefined by the header (in which case they are not // isBuiltinMacro). if (!MI || MI->isBuiltinMacro()) return 0; MacroID &ID = MacroIDs[MI]; if (ID == 0) { ID = NextMacroID++; MacroInfoToEmitData Info = { Name, MI, ID }; MacroInfosToEmit.push_back(Info); } return ID; } MacroID ASTWriter::getMacroID(MacroInfo *MI) { if (!MI || MI->isBuiltinMacro()) return 0; assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!"); return MacroIDs[MI]; } uint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) { assert(IdentMacroDirectivesOffsetMap[Name] && "not set!"); return IdentMacroDirectivesOffsetMap[Name]; } void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) { Record.push_back(getSelectorRef(SelRef)); } SelectorID ASTWriter::getSelectorRef(Selector Sel) { if (Sel.getAsOpaquePtr() == nullptr) { return 0; } SelectorID SID = SelectorIDs[Sel]; if (SID == 0 && Chain) { // This might trigger a ReadSelector callback, which will set the ID for // this selector. Chain->LoadSelector(Sel); SID = SelectorIDs[Sel]; } if (SID == 0) { SID = NextSelectorID++; SelectorIDs[Sel] = SID; } return SID; } void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) { AddDeclRef(Temp->getDestructor(), Record); } void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases, CXXBaseSpecifier const *BasesEnd, RecordDataImpl &Record) { assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded"); CXXBaseSpecifiersToWrite.push_back( QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID, Bases, BasesEnd)); Record.push_back(NextCXXBaseSpecifiersID++); } void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg, RecordDataImpl &Record) { switch (Kind) { case TemplateArgument::Expression: AddStmt(Arg.getAsExpr()); break; case TemplateArgument::Type: AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record); break; case TemplateArgument::Template: AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); AddSourceLocation(Arg.getTemplateNameLoc(), Record); break; case TemplateArgument::TemplateExpansion: AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); AddSourceLocation(Arg.getTemplateNameLoc(), Record); AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record); break; case TemplateArgument::Null: case TemplateArgument::Integral: case TemplateArgument::Declaration: case TemplateArgument::NullPtr: case TemplateArgument::Pack: // FIXME: Is this right? break; } } void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, RecordDataImpl &Record) { AddTemplateArgument(Arg.getArgument(), Record); if (Arg.getArgument().getKind() == TemplateArgument::Expression) { bool InfoHasSameExpr = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); Record.push_back(InfoHasSameExpr); if (InfoHasSameExpr) return; // Avoid storing the same expr twice. } AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(), Record); } void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordDataImpl &Record) { if (!TInfo) { AddTypeRef(QualType(), Record); return; } AddTypeLoc(TInfo->getTypeLoc(), Record); } void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) { AddTypeRef(TL.getType(), Record); TypeLocWriter TLW(*this, Record); for (; !TL.isNull(); TL = TL.getNextTypeLoc()) TLW.Visit(TL); } void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { Record.push_back(GetOrCreateTypeID(T)); } TypeID ASTWriter::GetOrCreateTypeID( QualType T) { assert(Context); return MakeTypeID(*Context, T, std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this)); } TypeID ASTWriter::getTypeID(QualType T) const { assert(Context); return MakeTypeID(*Context, T, std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this)); } TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); TypeIdx &Idx = TypeIdxs[T]; if (Idx.getIndex() == 0) { if (DoneWritingDeclsAndTypes) { assert(0 && "New type seen after serializing all the types to emit!"); return TypeIdx(); } // We haven't seen this type before. Assign it a new ID and put it // into the queue of types to emit. Idx = TypeIdx(NextTypeID++); DeclTypesToEmit.push(T); } return Idx; } TypeIdx ASTWriter::getTypeIdx(QualType T) const { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); TypeIdxMap::const_iterator I = TypeIdxs.find(T); assert(I != TypeIdxs.end() && "Type not emitted!"); return I->second; } void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { Record.push_back(GetDeclRef(D)); } DeclID ASTWriter::GetDeclRef(const Decl *D) { assert(WritingAST && "Cannot request a declaration ID before AST writing"); if (!D) { return 0; } // If D comes from an AST file, its declaration ID is already known and // fixed. if (D->isFromASTFile()) return D->getGlobalID(); assert(!(reinterpret_cast(D) & 0x01) && "Invalid decl pointer"); DeclID &ID = DeclIDs[D]; if (ID == 0) { if (DoneWritingDeclsAndTypes) { assert(0 && "New decl seen after serializing all the decls to emit!"); return 0; } // We haven't seen this declaration before. Give it a new ID and // enqueue it in the list of declarations to emit. ID = NextDeclID++; DeclTypesToEmit.push(const_cast(D)); } return ID; } DeclID ASTWriter::getDeclID(const Decl *D) { if (!D) return 0; // If D comes from an AST file, its declaration ID is already known and // fixed. if (D->isFromASTFile()) return D->getGlobalID(); assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); return DeclIDs[D]; } void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { assert(ID); assert(D); SourceLocation Loc = D->getLocation(); if (Loc.isInvalid()) return; // We only keep track of the file-level declarations of each file. if (!D->getLexicalDeclContext()->isFileContext()) return; // FIXME: ParmVarDecls that are part of a function type of a parameter of // a function/objc method, should not have TU as lexical context. if (isa(D)) return; SourceManager &SM = Context->getSourceManager(); SourceLocation FileLoc = SM.getFileLoc(Loc); assert(SM.isLocalSourceLocation(FileLoc)); FileID FID; unsigned Offset; std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); if (FID.isInvalid()) return; assert(SM.getSLocEntry(FID).isFile()); DeclIDInFileInfo *&Info = FileDeclIDs[FID]; if (!Info) Info = new DeclIDInFileInfo(); std::pair LocDecl(Offset, ID); LocDeclIDsTy &Decls = Info->DeclIDs; if (Decls.empty() || Decls.back().first <= Offset) { Decls.push_back(LocDecl); return; } LocDeclIDsTy::iterator I = std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first()); Decls.insert(I, LocDecl); } void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) { // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. Record.push_back(Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: AddIdentifierRef(Name.getAsIdentifierInfo(), Record); break; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: AddSelectorRef(Name.getObjCSelector(), Record); break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: AddTypeRef(Name.getCXXNameType(), Record); break; case DeclarationName::CXXOperatorName: Record.push_back(Name.getCXXOverloadedOperator()); break; case DeclarationName::CXXLiteralOperatorName: AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record); break; case DeclarationName::CXXUsingDirective: // No extra data to emit break; } } void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name, RecordDataImpl &Record) { switch (Name.getNameKind()) { case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record); break; case DeclarationName::CXXOperatorName: AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc), Record); AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc), Record); break; case DeclarationName::CXXLiteralOperatorName: AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc), Record); break; case DeclarationName::Identifier: case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: case DeclarationName::CXXUsingDirective: break; } } void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo, RecordDataImpl &Record) { AddDeclarationName(NameInfo.getName(), Record); AddSourceLocation(NameInfo.getLoc(), Record); AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record); } void ASTWriter::AddQualifierInfo(const QualifierInfo &Info, RecordDataImpl &Record) { AddNestedNameSpecifierLoc(Info.QualifierLoc, Record); Record.push_back(Info.NumTemplParamLists); for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i) AddTemplateParameterList(Info.TemplParamLists[i], Record); } void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS, RecordDataImpl &Record) { // Nested name specifiers usually aren't too long. I think that 8 would // typically accommodate the vast majority. SmallVector NestedNames; // Push each of the NNS's onto a stack for serialization in reverse order. while (NNS) { NestedNames.push_back(NNS); NNS = NNS->getPrefix(); } Record.push_back(NestedNames.size()); while(!NestedNames.empty()) { NNS = NestedNames.pop_back_val(); NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); Record.push_back(Kind); switch (Kind) { case NestedNameSpecifier::Identifier: AddIdentifierRef(NNS->getAsIdentifier(), Record); break; case NestedNameSpecifier::Namespace: AddDeclRef(NNS->getAsNamespace(), Record); break; case NestedNameSpecifier::NamespaceAlias: AddDeclRef(NNS->getAsNamespaceAlias(), Record); break; case NestedNameSpecifier::TypeSpec: case NestedNameSpecifier::TypeSpecWithTemplate: AddTypeRef(QualType(NNS->getAsType(), 0), Record); Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); break; case NestedNameSpecifier::Global: // Don't need to write an associated value. break; } } } void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, RecordDataImpl &Record) { // Nested name specifiers usually aren't too long. I think that 8 would // typically accommodate the vast majority. SmallVector NestedNames; // Push each of the nested-name-specifiers's onto a stack for // serialization in reverse order. while (NNS) { NestedNames.push_back(NNS); NNS = NNS.getPrefix(); } Record.push_back(NestedNames.size()); while(!NestedNames.empty()) { NNS = NestedNames.pop_back_val(); NestedNameSpecifier::SpecifierKind Kind = NNS.getNestedNameSpecifier()->getKind(); Record.push_back(Kind); switch (Kind) { case NestedNameSpecifier::Identifier: AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::Namespace: AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::NamespaceAlias: AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::TypeSpec: case NestedNameSpecifier::TypeSpecWithTemplate: Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); AddTypeLoc(NNS.getTypeLoc(), Record); AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); break; case NestedNameSpecifier::Global: AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); break; } } } void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) { TemplateName::NameKind Kind = Name.getKind(); Record.push_back(Kind); switch (Kind) { case TemplateName::Template: AddDeclRef(Name.getAsTemplateDecl(), Record); break; case TemplateName::OverloadedTemplate: { OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); Record.push_back(OvT->size()); for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end(); I != E; ++I) AddDeclRef(*I, Record); break; } case TemplateName::QualifiedTemplate: { QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); AddNestedNameSpecifier(QualT->getQualifier(), Record); Record.push_back(QualT->hasTemplateKeyword()); AddDeclRef(QualT->getTemplateDecl(), Record); break; } case TemplateName::DependentTemplate: { DependentTemplateName *DepT = Name.getAsDependentTemplateName(); AddNestedNameSpecifier(DepT->getQualifier(), Record); Record.push_back(DepT->isIdentifier()); if (DepT->isIdentifier()) AddIdentifierRef(DepT->getIdentifier(), Record); else Record.push_back(DepT->getOperator()); break; } case TemplateName::SubstTemplateTemplateParm: { SubstTemplateTemplateParmStorage *subst = Name.getAsSubstTemplateTemplateParm(); AddDeclRef(subst->getParameter(), Record); AddTemplateName(subst->getReplacement(), Record); break; } case TemplateName::SubstTemplateTemplateParmPack: { SubstTemplateTemplateParmPackStorage *SubstPack = Name.getAsSubstTemplateTemplateParmPack(); AddDeclRef(SubstPack->getParameterPack(), Record); AddTemplateArgument(SubstPack->getArgumentPack(), Record); break; } } } void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, RecordDataImpl &Record) { Record.push_back(Arg.getKind()); switch (Arg.getKind()) { case TemplateArgument::Null: break; case TemplateArgument::Type: AddTypeRef(Arg.getAsType(), Record); break; case TemplateArgument::Declaration: AddDeclRef(Arg.getAsDecl(), Record); Record.push_back(Arg.isDeclForReferenceParam()); break; case TemplateArgument::NullPtr: AddTypeRef(Arg.getNullPtrType(), Record); break; case TemplateArgument::Integral: AddAPSInt(Arg.getAsIntegral(), Record); AddTypeRef(Arg.getIntegralType(), Record); break; case TemplateArgument::Template: AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); break; case TemplateArgument::TemplateExpansion: AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); if (Optional NumExpansions = Arg.getNumTemplateExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); break; case TemplateArgument::Expression: AddStmt(Arg.getAsExpr()); break; case TemplateArgument::Pack: Record.push_back(Arg.pack_size()); for (const auto &P : Arg.pack_elements()) AddTemplateArgument(P, Record); break; } } void ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams, RecordDataImpl &Record) { assert(TemplateParams && "No TemplateParams!"); AddSourceLocation(TemplateParams->getTemplateLoc(), Record); AddSourceLocation(TemplateParams->getLAngleLoc(), Record); AddSourceLocation(TemplateParams->getRAngleLoc(), Record); Record.push_back(TemplateParams->size()); for (TemplateParameterList::const_iterator P = TemplateParams->begin(), PEnd = TemplateParams->end(); P != PEnd; ++P) AddDeclRef(*P, Record); } /// \brief Emit a template argument list. void ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs, RecordDataImpl &Record) { assert(TemplateArgs && "No TemplateArgs!"); Record.push_back(TemplateArgs->size()); for (int i=0, e = TemplateArgs->size(); i != e; ++i) AddTemplateArgument(TemplateArgs->get(i), Record); } void ASTWriter::AddASTTemplateArgumentListInfo (const ASTTemplateArgumentListInfo *ASTTemplArgList, RecordDataImpl &Record) { assert(ASTTemplArgList && "No ASTTemplArgList!"); AddSourceLocation(ASTTemplArgList->LAngleLoc, Record); AddSourceLocation(ASTTemplArgList->RAngleLoc, Record); Record.push_back(ASTTemplArgList->NumTemplateArgs); const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs(); for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) AddTemplateArgumentLoc(TemplArgs[i], Record); } void ASTWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record) { Record.push_back(Set.size()); for (ASTUnresolvedSet::const_iterator I = Set.begin(), E = Set.end(); I != E; ++I) { AddDeclRef(I.getDecl(), Record); Record.push_back(I.getAccess()); } } void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, RecordDataImpl &Record) { Record.push_back(Base.isVirtual()); Record.push_back(Base.isBaseOfClass()); Record.push_back(Base.getAccessSpecifierAsWritten()); Record.push_back(Base.getInheritConstructors()); AddTypeSourceInfo(Base.getTypeSourceInfo(), Record); AddSourceRange(Base.getSourceRange(), Record); AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() : SourceLocation(), Record); } void ASTWriter::FlushCXXBaseSpecifiers() { RecordData Record; for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) { Record.clear(); // Record the offset of this base-specifier set. unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1; if (Index == CXXBaseSpecifiersOffsets.size()) CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo()); else { if (Index > CXXBaseSpecifiersOffsets.size()) CXXBaseSpecifiersOffsets.resize(Index + 1); CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo(); } const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases, *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd; Record.push_back(BEnd - B); for (; B != BEnd; ++B) AddCXXBaseSpecifier(*B, Record); Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record); // Flush any expressions that were written as part of the base specifiers. FlushStmts(); } CXXBaseSpecifiersToWrite.clear(); } void ASTWriter::AddCXXCtorInitializers( const CXXCtorInitializer * const *CtorInitializers, unsigned NumCtorInitializers, RecordDataImpl &Record) { Record.push_back(NumCtorInitializers); for (unsigned i=0; i != NumCtorInitializers; ++i) { const CXXCtorInitializer *Init = CtorInitializers[i]; if (Init->isBaseInitializer()) { Record.push_back(CTOR_INITIALIZER_BASE); AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); Record.push_back(Init->isBaseVirtual()); } else if (Init->isDelegatingInitializer()) { Record.push_back(CTOR_INITIALIZER_DELEGATING); AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); } else if (Init->isMemberInitializer()){ Record.push_back(CTOR_INITIALIZER_MEMBER); AddDeclRef(Init->getMember(), Record); } else { Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); AddDeclRef(Init->getIndirectMember(), Record); } AddSourceLocation(Init->getMemberLocation(), Record); AddStmt(Init->getInit()); AddSourceLocation(Init->getLParenLoc(), Record); AddSourceLocation(Init->getRParenLoc(), Record); Record.push_back(Init->isWritten()); if (Init->isWritten()) { Record.push_back(Init->getSourceOrder()); } else { Record.push_back(Init->getNumArrayIndices()); for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i) AddDeclRef(Init->getArrayIndex(i), Record); } } } void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) { auto &Data = D->data(); Record.push_back(Data.IsLambda); Record.push_back(Data.UserDeclaredConstructor); Record.push_back(Data.UserDeclaredSpecialMembers); Record.push_back(Data.Aggregate); Record.push_back(Data.PlainOldData); Record.push_back(Data.Empty); Record.push_back(Data.Polymorphic); Record.push_back(Data.Abstract); Record.push_back(Data.IsStandardLayout); Record.push_back(Data.HasNoNonEmptyBases); Record.push_back(Data.HasPrivateFields); Record.push_back(Data.HasProtectedFields); Record.push_back(Data.HasPublicFields); Record.push_back(Data.HasMutableFields); Record.push_back(Data.HasVariantMembers); Record.push_back(Data.HasOnlyCMembers); Record.push_back(Data.HasInClassInitializer); Record.push_back(Data.HasUninitializedReferenceMember); Record.push_back(Data.NeedOverloadResolutionForMoveConstructor); Record.push_back(Data.NeedOverloadResolutionForMoveAssignment); Record.push_back(Data.NeedOverloadResolutionForDestructor); Record.push_back(Data.DefaultedMoveConstructorIsDeleted); Record.push_back(Data.DefaultedMoveAssignmentIsDeleted); Record.push_back(Data.DefaultedDestructorIsDeleted); Record.push_back(Data.HasTrivialSpecialMembers); Record.push_back(Data.DeclaredNonTrivialSpecialMembers); Record.push_back(Data.HasIrrelevantDestructor); Record.push_back(Data.HasConstexprNonCopyMoveConstructor); Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr); Record.push_back(Data.HasConstexprDefaultConstructor); Record.push_back(Data.HasNonLiteralTypeFieldsOrBases); Record.push_back(Data.ComputedVisibleConversions); Record.push_back(Data.UserProvidedDefaultConstructor); Record.push_back(Data.DeclaredSpecialMembers); Record.push_back(Data.ImplicitCopyConstructorHasConstParam); Record.push_back(Data.ImplicitCopyAssignmentHasConstParam); Record.push_back(Data.HasDeclaredCopyConstructorWithConstParam); Record.push_back(Data.HasDeclaredCopyAssignmentWithConstParam); // IsLambda bit is already saved. Record.push_back(Data.NumBases); if (Data.NumBases > 0) AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases, Record); // FIXME: Make VBases lazily computed when needed to avoid storing them. Record.push_back(Data.NumVBases); if (Data.NumVBases > 0) AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases, Record); AddUnresolvedSet(Data.Conversions.get(*Context), Record); AddUnresolvedSet(Data.VisibleConversions.get(*Context), Record); // Data.Definition is the owning decl, no need to write it. AddDeclRef(D->getFirstFriend(), Record); // Add lambda-specific data. if (Data.IsLambda) { auto &Lambda = D->getLambdaData(); Record.push_back(Lambda.Dependent); Record.push_back(Lambda.IsGenericLambda); Record.push_back(Lambda.CaptureDefault); Record.push_back(Lambda.NumCaptures); Record.push_back(Lambda.NumExplicitCaptures); Record.push_back(Lambda.ManglingNumber); AddDeclRef(Lambda.ContextDecl, Record); AddTypeSourceInfo(Lambda.MethodTyInfo, Record); for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { const LambdaCapture &Capture = Lambda.Captures[I]; AddSourceLocation(Capture.getLocation(), Record); Record.push_back(Capture.isImplicit()); Record.push_back(Capture.getCaptureKind()); switch (Capture.getCaptureKind()) { case LCK_This: break; case LCK_ByCopy: case LCK_ByRef: VarDecl *Var = Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr; AddDeclRef(Var, Record); AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc() : SourceLocation(), Record); break; } } } } void ASTWriter::ReaderInitialized(ASTReader *Reader) { assert(Reader && "Cannot remove chain"); assert((!Chain || Chain == Reader) && "Cannot replace chain"); assert(FirstDeclID == NextDeclID && FirstTypeID == NextTypeID && FirstIdentID == NextIdentID && FirstMacroID == NextMacroID && FirstSubmoduleID == NextSubmoduleID && FirstSelectorID == NextSelectorID && "Setting chain after writing has started."); Chain = Reader; FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros(); FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); NextDeclID = FirstDeclID; NextTypeID = FirstTypeID; NextIdentID = FirstIdentID; NextMacroID = FirstMacroID; NextSelectorID = FirstSelectorID; NextSubmoduleID = FirstSubmoduleID; } void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { // Always keep the highest ID. See \p TypeRead() for more information. IdentID &StoredID = IdentifierIDs[II]; if (ID > StoredID) StoredID = ID; } void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) { // Always keep the highest ID. See \p TypeRead() for more information. MacroID &StoredID = MacroIDs[MI]; if (ID > StoredID) StoredID = ID; } void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { // Always take the highest-numbered type index. This copes with an interesting // case for chained AST writing where we schedule writing the type and then, // later, deserialize the type from another AST. In this case, we want to // keep the higher-numbered entry so that we can properly write it out to // the AST file. TypeIdx &StoredIdx = TypeIdxs[T]; if (Idx.getIndex() >= StoredIdx.getIndex()) StoredIdx = Idx; } void ASTWriter::SelectorRead(SelectorID ID, Selector S) { // Always keep the highest ID. See \p TypeRead() for more information. SelectorID &StoredID = SelectorIDs[S]; if (ID > StoredID) StoredID = ID; } void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, MacroDefinition *MD) { assert(MacroDefinitions.find(MD) == MacroDefinitions.end()); MacroDefinitions[MD] = ID; } void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); SubmoduleIDs[Mod] = ID; } void ASTWriter::CompletedTagDefinition(const TagDecl *D) { assert(D->isCompleteDefinition()); assert(!WritingAST && "Already writing the AST!"); if (const CXXRecordDecl *RD = dyn_cast(D)) { // We are interested when a PCH decl is modified. if (RD->isFromASTFile()) { // A forward reference was mutated into a definition. Rewrite it. // FIXME: This happens during template instantiation, should we // have created a new definition decl instead ? assert(isTemplateInstantiation(RD->getTemplateSpecializationKind()) && "completed a tag from another module but not by instantiation?"); DeclUpdates[RD].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_CLASS_DEFINITION)); } } } void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { assert(!WritingAST && "Already writing the AST!"); // TU and namespaces are handled elsewhere. if (isa(DC) || isa(DC)) return; if (!(!D->isFromASTFile() && cast(DC)->isFromASTFile())) return; // Not a source decl added to a DeclContext from PCH. assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!"); AddUpdatedDeclContext(DC); UpdatingVisibleDecls.push_back(D); } void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { assert(!WritingAST && "Already writing the AST!"); assert(D->isImplicit()); if (!(!D->isFromASTFile() && RD->isFromASTFile())) return; // Not a source member added to a class from PCH. if (!isa(D)) return; // We are interested in lazily declared implicit methods. // A decl coming from PCH was modified. assert(RD->isCompleteDefinition()); DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D)); } void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); } void ASTWriter::AddedCXXTemplateSpecialization( const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); } void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, const FunctionDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, D)); } void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) { assert(!WritingAST && "Already writing the AST!"); FD = FD->getCanonicalDecl(); if (!FD->isFromASTFile()) return; // Not a function declared in PCH and defined outside. DeclUpdates[FD].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC); } void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { assert(!WritingAST && "Already writing the AST!"); FD = FD->getCanonicalDecl(); if (!FD->isFromASTFile()) return; // Not a function declared in PCH and defined outside. DeclUpdates[FD].push_back(DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType)); } void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Declaration not imported from PCH. // Implicit function decl from a PCH was defined. DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); } void ASTWriter::FunctionDefinitionInstantiated(const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); } void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Since the actual instantiation is delayed, this really means that we need // to update the instantiation location. DeclUpdates[D].push_back( DeclUpdate(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER, D->getMemberSpecializationInfo()->getPointOfInstantiation())); } void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, const ObjCInterfaceDecl *IFD) { assert(!WritingAST && "Already writing the AST!"); if (!IFD->isFromASTFile()) return; // Declaration not imported from PCH. assert(IFD->getDefinition() && "Category on a class without a definition?"); ObjCClassesWithCategories.insert( const_cast(IFD->getDefinition())); } void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, const ObjCPropertyDecl *OrigProp, const ObjCCategoryDecl *ClassExt) { const ObjCInterfaceDecl *D = ClassExt->getClassInterface(); if (!D) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Declaration not imported from PCH. RewriteDecl(D); } void ASTWriter::DeclarationMarkedUsed(const Decl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_USED)); } @ 1.1.1.5.4.1 log @file ASTWriter.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:30 +0000 @ text @d1 5415 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 5415 //===--- ASTWriter.cpp - AST File Writer ----------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the ASTWriter class, which writes AST files. // //===----------------------------------------------------------------------===// #include "clang/Serialization/ASTWriter.h" #include "ASTCommon.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclContextInternals.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLocVisitor.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/FileSystemStatCache.h" #include "clang/Basic/OnDiskHashTable.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManagerInternals.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Basic/Version.h" #include "clang/Basic/VersionTuple.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/PreprocessingRecord.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/PreprocessorOptions.h" #include "clang/Sema/IdentifierResolver.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/Hashing.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include #include #include #include using namespace clang; using namespace clang::serialization; template static StringRef data(const std::vector &v) { if (v.empty()) return StringRef(); return StringRef(reinterpret_cast(&v[0]), sizeof(T) * v.size()); } template static StringRef data(const SmallVectorImpl &v) { return StringRef(reinterpret_cast(v.data()), sizeof(T) * v.size()); } //===----------------------------------------------------------------------===// // Type serialization //===----------------------------------------------------------------------===// namespace { class ASTTypeWriter { ASTWriter &Writer; ASTWriter::RecordDataImpl &Record; public: /// \brief Type code that corresponds to the record generated. TypeCode Code; ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { } void VisitArrayType(const ArrayType *T); void VisitFunctionType(const FunctionType *T); void VisitTagType(const TagType *T); #define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" }; } void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { llvm_unreachable("Built-in types are never serialized"); } void ASTTypeWriter::VisitComplexType(const ComplexType *T) { Writer.AddTypeRef(T->getElementType(), Record); Code = TYPE_COMPLEX; } void ASTTypeWriter::VisitPointerType(const PointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_POINTER; } void ASTTypeWriter::VisitDecayedType(const DecayedType *T) { Writer.AddTypeRef(T->getOriginalType(), Record); Code = TYPE_DECAYED; } void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) { Writer.AddTypeRef(T->getOriginalType(), Record); Writer.AddTypeRef(T->getAdjustedType(), Record); Code = TYPE_ADJUSTED; } void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_BLOCK_POINTER; } void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); Record.push_back(T->isSpelledAsLValue()); Code = TYPE_LVALUE_REFERENCE; } void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); Code = TYPE_RVALUE_REFERENCE; } void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Writer.AddTypeRef(QualType(T->getClass(), 0), Record); Code = TYPE_MEMBER_POINTER; } void ASTTypeWriter::VisitArrayType(const ArrayType *T) { Writer.AddTypeRef(T->getElementType(), Record); Record.push_back(T->getSizeModifier()); // FIXME: stable values Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values } void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { VisitArrayType(T); Writer.AddAPInt(T->getSize(), Record); Code = TYPE_CONSTANT_ARRAY; } void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { VisitArrayType(T); Code = TYPE_INCOMPLETE_ARRAY; } void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { VisitArrayType(T); Writer.AddSourceLocation(T->getLBracketLoc(), Record); Writer.AddSourceLocation(T->getRBracketLoc(), Record); Writer.AddStmt(T->getSizeExpr()); Code = TYPE_VARIABLE_ARRAY; } void ASTTypeWriter::VisitVectorType(const VectorType *T) { Writer.AddTypeRef(T->getElementType(), Record); Record.push_back(T->getNumElements()); Record.push_back(T->getVectorKind()); Code = TYPE_VECTOR; } void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { VisitVectorType(T); Code = TYPE_EXT_VECTOR; } void ASTTypeWriter::VisitFunctionType(const FunctionType *T) { Writer.AddTypeRef(T->getReturnType(), Record); FunctionType::ExtInfo C = T->getExtInfo(); Record.push_back(C.getNoReturn()); Record.push_back(C.getHasRegParm()); Record.push_back(C.getRegParm()); // FIXME: need to stabilize encoding of calling convention... Record.push_back(C.getCC()); Record.push_back(C.getProducesResult()); } void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { VisitFunctionType(T); Code = TYPE_FUNCTION_NO_PROTO; } void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { VisitFunctionType(T); Record.push_back(T->getNumParams()); for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) Writer.AddTypeRef(T->getParamType(I), Record); Record.push_back(T->isVariadic()); Record.push_back(T->hasTrailingReturn()); Record.push_back(T->getTypeQuals()); Record.push_back(static_cast(T->getRefQualifier())); Record.push_back(T->getExceptionSpecType()); if (T->getExceptionSpecType() == EST_Dynamic) { Record.push_back(T->getNumExceptions()); for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) Writer.AddTypeRef(T->getExceptionType(I), Record); } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) { Writer.AddStmt(T->getNoexceptExpr()); } else if (T->getExceptionSpecType() == EST_Uninstantiated) { Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record); } else if (T->getExceptionSpecType() == EST_Unevaluated) { Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); } Code = TYPE_FUNCTION_PROTO; } void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { Writer.AddDeclRef(T->getDecl(), Record); Code = TYPE_UNRESOLVED_USING; } void ASTTypeWriter::VisitTypedefType(const TypedefType *T) { Writer.AddDeclRef(T->getDecl(), Record); assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record); Code = TYPE_TYPEDEF; } void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { Writer.AddStmt(T->getUnderlyingExpr()); Code = TYPE_TYPEOF_EXPR; } void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { Writer.AddTypeRef(T->getUnderlyingType(), Record); Code = TYPE_TYPEOF; } void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { Writer.AddTypeRef(T->getUnderlyingType(), Record); Writer.AddStmt(T->getUnderlyingExpr()); Code = TYPE_DECLTYPE; } void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) { Writer.AddTypeRef(T->getBaseType(), Record); Writer.AddTypeRef(T->getUnderlyingType(), Record); Record.push_back(T->getUTTKind()); Code = TYPE_UNARY_TRANSFORM; } void ASTTypeWriter::VisitAutoType(const AutoType *T) { Writer.AddTypeRef(T->getDeducedType(), Record); Record.push_back(T->isDecltypeAuto()); if (T->getDeducedType().isNull()) Record.push_back(T->isDependentType()); Code = TYPE_AUTO; } void ASTTypeWriter::VisitTagType(const TagType *T) { Record.push_back(T->isDependentType()); Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); assert(!T->isBeingDefined() && "Cannot serialize in the middle of a type definition"); } void ASTTypeWriter::VisitRecordType(const RecordType *T) { VisitTagType(T); Code = TYPE_RECORD; } void ASTTypeWriter::VisitEnumType(const EnumType *T) { VisitTagType(T); Code = TYPE_ENUM; } void ASTTypeWriter::VisitAttributedType(const AttributedType *T) { Writer.AddTypeRef(T->getModifiedType(), Record); Writer.AddTypeRef(T->getEquivalentType(), Record); Record.push_back(T->getAttrKind()); Code = TYPE_ATTRIBUTED; } void ASTTypeWriter::VisitSubstTemplateTypeParmType( const SubstTemplateTypeParmType *T) { Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); Writer.AddTypeRef(T->getReplacementType(), Record); Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; } void ASTTypeWriter::VisitSubstTemplateTypeParmPackType( const SubstTemplateTypeParmPackType *T) { Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); Writer.AddTemplateArgument(T->getArgumentPack(), Record); Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK; } void ASTTypeWriter::VisitTemplateSpecializationType( const TemplateSpecializationType *T) { Record.push_back(T->isDependentType()); Writer.AddTemplateName(T->getTemplateName(), Record); Record.push_back(T->getNumArgs()); for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end(); ArgI != ArgE; ++ArgI) Writer.AddTemplateArgument(*ArgI, Record); Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() : T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal(), Record); Code = TYPE_TEMPLATE_SPECIALIZATION; } void ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { VisitArrayType(T); Writer.AddStmt(T->getSizeExpr()); Writer.AddSourceRange(T->getBracketsRange(), Record); Code = TYPE_DEPENDENT_SIZED_ARRAY; } void ASTTypeWriter::VisitDependentSizedExtVectorType( const DependentSizedExtVectorType *T) { // FIXME: Serialize this type (C++ only) llvm_unreachable("Cannot serialize dependent sized extended vector types"); } void ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { Record.push_back(T->getDepth()); Record.push_back(T->getIndex()); Record.push_back(T->isParameterPack()); Writer.AddDeclRef(T->getDecl(), Record); Code = TYPE_TEMPLATE_TYPE_PARM; } void ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddIdentifierRef(T->getIdentifier(), Record); Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal(), Record); Code = TYPE_DEPENDENT_NAME; } void ASTTypeWriter::VisitDependentTemplateSpecializationType( const DependentTemplateSpecializationType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddIdentifierRef(T->getIdentifier(), Record); Record.push_back(T->getNumArgs()); for (DependentTemplateSpecializationType::iterator I = T->begin(), E = T->end(); I != E; ++I) Writer.AddTemplateArgument(*I, Record); Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; } void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { Writer.AddTypeRef(T->getPattern(), Record); if (Optional NumExpansions = T->getNumExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); Code = TYPE_PACK_EXPANSION; } void ASTTypeWriter::VisitParenType(const ParenType *T) { Writer.AddTypeRef(T->getInnerType(), Record); Code = TYPE_PAREN; } void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { Record.push_back(T->getKeyword()); Writer.AddNestedNameSpecifier(T->getQualifier(), Record); Writer.AddTypeRef(T->getNamedType(), Record); Code = TYPE_ELABORATED; } void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); Code = TYPE_INJECTED_CLASS_NAME; } void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Code = TYPE_OBJC_INTERFACE; } void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { Writer.AddTypeRef(T->getBaseType(), Record); Record.push_back(T->getNumProtocols()); for (ObjCObjectType::qual_iterator I = T->qual_begin(), E = T->qual_end(); I != E; ++I) Writer.AddDeclRef(*I, Record); Code = TYPE_OBJC_OBJECT; } void ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { Writer.AddTypeRef(T->getPointeeType(), Record); Code = TYPE_OBJC_OBJECT_POINTER; } void ASTTypeWriter::VisitAtomicType(const AtomicType *T) { Writer.AddTypeRef(T->getValueType(), Record); Code = TYPE_ATOMIC; } namespace { class TypeLocWriter : public TypeLocVisitor { ASTWriter &Writer; ASTWriter::RecordDataImpl &Record; public: TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) : Writer(Writer), Record(Record) { } #define ABSTRACT_TYPELOC(CLASS, PARENT) #define TYPELOC(CLASS, PARENT) \ void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); #include "clang/AST/TypeLocNodes.def" void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); }; } void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { Writer.AddSourceLocation(TL.getBuiltinLoc(), Record); if (TL.needsExtraLocalData()) { Record.push_back(TL.getWrittenTypeSpec()); Record.push_back(TL.getWrittenSignSpec()); Record.push_back(TL.getWrittenWidthSpec()); Record.push_back(TL.hasModeAttr()); } } void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); } void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { // nothing to do } void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getCaretLoc(), Record); } void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { Writer.AddSourceLocation(TL.getAmpLoc(), Record); } void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record); } void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record); } void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { Writer.AddSourceLocation(TL.getLBracketLoc(), Record); Writer.AddSourceLocation(TL.getRBracketLoc(), Record); Record.push_back(TL.getSizeExpr() ? 1 : 0); if (TL.getSizeExpr()) Writer.AddStmt(TL.getSizeExpr()); } void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitDependentSizedArrayTypeLoc( DependentSizedArrayTypeLoc TL) { VisitArrayTypeLoc(TL); } void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( DependentSizedExtVectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record); for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) Writer.AddDeclRef(TL.getParam(i), Record); } void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { VisitFunctionTypeLoc(TL); } void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { VisitFunctionTypeLoc(TL); } void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { Writer.AddSourceLocation(TL.getTypeofLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { Writer.AddSourceLocation(TL.getTypeofLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); } void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { Writer.AddSourceLocation(TL.getKWLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); } void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { Writer.AddSourceLocation(TL.getAttrNameLoc(), Record); if (TL.hasAttrOperand()) { SourceRange range = TL.getAttrOperandParensRange(); Writer.AddSourceLocation(range.getBegin(), Record); Writer.AddSourceLocation(range.getEnd(), Record); } if (TL.hasAttrExprOperand()) { Expr *operand = TL.getAttrExprOperand(); Record.push_back(operand ? 1 : 0); if (operand) Writer.AddStmt(operand); } else if (TL.hasAttrEnumOperand()) { Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record); } } void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( SubstTemplateTypeParmTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( SubstTemplateTypeParmPackTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitTemplateSpecializationTypeLoc( TemplateSpecializationTypeLoc TL) { Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), TL.getArgLoc(i).getLocInfo(), Record); } void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); } void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( DependentTemplateSpecializationTypeLoc TL) { Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), TL.getArgLoc(I).getLocInfo(), Record); } void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { Writer.AddSourceLocation(TL.getEllipsisLoc(), Record); } void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { Record.push_back(TL.hasBaseTypeAsWritten()); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) Writer.AddSourceLocation(TL.getProtocolLoc(i), Record); } void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { Writer.AddSourceLocation(TL.getStarLoc(), Record); } void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) { Writer.AddSourceLocation(TL.getKWLoc(), Record); Writer.AddSourceLocation(TL.getLParenLoc(), Record); Writer.AddSourceLocation(TL.getRParenLoc(), Record); } //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// static void EmitBlockID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { Record.clear(); Record.push_back(ID); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); // Emit the block name if present. if (Name == 0 || Name[0] == 0) return; Record.clear(); while (*Name) Record.push_back(*Name++); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); } static void EmitRecordID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { Record.clear(); Record.push_back(ID); while (*Name) Record.push_back(*Name++); Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); } static void AddStmtsExprs(llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record) { #define RECORD(X) EmitRecordID(X, #X, Stream, Record) RECORD(STMT_STOP); RECORD(STMT_NULL_PTR); RECORD(STMT_NULL); RECORD(STMT_COMPOUND); RECORD(STMT_CASE); RECORD(STMT_DEFAULT); RECORD(STMT_LABEL); RECORD(STMT_ATTRIBUTED); RECORD(STMT_IF); RECORD(STMT_SWITCH); RECORD(STMT_WHILE); RECORD(STMT_DO); RECORD(STMT_FOR); RECORD(STMT_GOTO); RECORD(STMT_INDIRECT_GOTO); RECORD(STMT_CONTINUE); RECORD(STMT_BREAK); RECORD(STMT_RETURN); RECORD(STMT_DECL); RECORD(STMT_GCCASM); RECORD(STMT_MSASM); RECORD(EXPR_PREDEFINED); RECORD(EXPR_DECL_REF); RECORD(EXPR_INTEGER_LITERAL); RECORD(EXPR_FLOATING_LITERAL); RECORD(EXPR_IMAGINARY_LITERAL); RECORD(EXPR_STRING_LITERAL); RECORD(EXPR_CHARACTER_LITERAL); RECORD(EXPR_PAREN); RECORD(EXPR_UNARY_OPERATOR); RECORD(EXPR_SIZEOF_ALIGN_OF); RECORD(EXPR_ARRAY_SUBSCRIPT); RECORD(EXPR_CALL); RECORD(EXPR_MEMBER); RECORD(EXPR_BINARY_OPERATOR); RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); RECORD(EXPR_CONDITIONAL_OPERATOR); RECORD(EXPR_IMPLICIT_CAST); RECORD(EXPR_CSTYLE_CAST); RECORD(EXPR_COMPOUND_LITERAL); RECORD(EXPR_EXT_VECTOR_ELEMENT); RECORD(EXPR_INIT_LIST); RECORD(EXPR_DESIGNATED_INIT); RECORD(EXPR_IMPLICIT_VALUE_INIT); RECORD(EXPR_VA_ARG); RECORD(EXPR_ADDR_LABEL); RECORD(EXPR_STMT); RECORD(EXPR_CHOOSE); RECORD(EXPR_GNU_NULL); RECORD(EXPR_SHUFFLE_VECTOR); RECORD(EXPR_BLOCK); RECORD(EXPR_GENERIC_SELECTION); RECORD(EXPR_OBJC_STRING_LITERAL); RECORD(EXPR_OBJC_BOXED_EXPRESSION); RECORD(EXPR_OBJC_ARRAY_LITERAL); RECORD(EXPR_OBJC_DICTIONARY_LITERAL); RECORD(EXPR_OBJC_ENCODE); RECORD(EXPR_OBJC_SELECTOR_EXPR); RECORD(EXPR_OBJC_PROTOCOL_EXPR); RECORD(EXPR_OBJC_IVAR_REF_EXPR); RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); RECORD(EXPR_OBJC_KVC_REF_EXPR); RECORD(EXPR_OBJC_MESSAGE_EXPR); RECORD(STMT_OBJC_FOR_COLLECTION); RECORD(STMT_OBJC_CATCH); RECORD(STMT_OBJC_FINALLY); RECORD(STMT_OBJC_AT_TRY); RECORD(STMT_OBJC_AT_SYNCHRONIZED); RECORD(STMT_OBJC_AT_THROW); RECORD(EXPR_OBJC_BOOL_LITERAL); RECORD(EXPR_CXX_OPERATOR_CALL); RECORD(EXPR_CXX_CONSTRUCT); RECORD(EXPR_CXX_STATIC_CAST); RECORD(EXPR_CXX_DYNAMIC_CAST); RECORD(EXPR_CXX_REINTERPRET_CAST); RECORD(EXPR_CXX_CONST_CAST); RECORD(EXPR_CXX_FUNCTIONAL_CAST); RECORD(EXPR_USER_DEFINED_LITERAL); RECORD(EXPR_CXX_STD_INITIALIZER_LIST); RECORD(EXPR_CXX_BOOL_LITERAL); RECORD(EXPR_CXX_NULL_PTR_LITERAL); RECORD(EXPR_CXX_TYPEID_EXPR); RECORD(EXPR_CXX_TYPEID_TYPE); RECORD(EXPR_CXX_UUIDOF_EXPR); RECORD(EXPR_CXX_UUIDOF_TYPE); RECORD(EXPR_CXX_THIS); RECORD(EXPR_CXX_THROW); RECORD(EXPR_CXX_DEFAULT_ARG); RECORD(EXPR_CXX_BIND_TEMPORARY); RECORD(EXPR_CXX_SCALAR_VALUE_INIT); RECORD(EXPR_CXX_NEW); RECORD(EXPR_CXX_DELETE); RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR); RECORD(EXPR_EXPR_WITH_CLEANUPS); RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER); RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF); RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT); RECORD(EXPR_CXX_UNRESOLVED_MEMBER); RECORD(EXPR_CXX_UNRESOLVED_LOOKUP); RECORD(EXPR_CXX_NOEXCEPT); RECORD(EXPR_OPAQUE_VALUE); RECORD(EXPR_PACK_EXPANSION); RECORD(EXPR_SIZEOF_PACK); RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK); RECORD(EXPR_CUDA_KERNEL_CALL); #undef RECORD } void ASTWriter::WriteBlockInfoBlock() { RecordData Record; Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) #define RECORD(X) EmitRecordID(X, #X, Stream, Record) // Control Block. BLOCK(CONTROL_BLOCK); RECORD(METADATA); RECORD(IMPORTS); RECORD(LANGUAGE_OPTIONS); RECORD(TARGET_OPTIONS); RECORD(ORIGINAL_FILE); RECORD(ORIGINAL_PCH_DIR); RECORD(ORIGINAL_FILE_ID); RECORD(INPUT_FILE_OFFSETS); RECORD(DIAGNOSTIC_OPTIONS); RECORD(FILE_SYSTEM_OPTIONS); RECORD(HEADER_SEARCH_OPTIONS); RECORD(PREPROCESSOR_OPTIONS); BLOCK(INPUT_FILES_BLOCK); RECORD(INPUT_FILE); // AST Top-Level Block. BLOCK(AST_BLOCK); RECORD(TYPE_OFFSET); RECORD(DECL_OFFSET); RECORD(IDENTIFIER_OFFSET); RECORD(IDENTIFIER_TABLE); RECORD(EAGERLY_DESERIALIZED_DECLS); RECORD(SPECIAL_TYPES); RECORD(STATISTICS); RECORD(TENTATIVE_DEFINITIONS); RECORD(UNUSED_FILESCOPED_DECLS); RECORD(LOCALLY_SCOPED_EXTERN_C_DECLS); RECORD(SELECTOR_OFFSETS); RECORD(METHOD_POOL); RECORD(PP_COUNTER_VALUE); RECORD(SOURCE_LOCATION_OFFSETS); RECORD(SOURCE_LOCATION_PRELOADS); RECORD(EXT_VECTOR_DECLS); RECORD(PPD_ENTITIES_OFFSETS); RECORD(REFERENCED_SELECTOR_POOL); RECORD(TU_UPDATE_LEXICAL); RECORD(LOCAL_REDECLARATIONS_MAP); RECORD(SEMA_DECL_REFS); RECORD(WEAK_UNDECLARED_IDENTIFIERS); RECORD(PENDING_IMPLICIT_INSTANTIATIONS); RECORD(DECL_REPLACEMENTS); RECORD(UPDATE_VISIBLE); RECORD(DECL_UPDATE_OFFSETS); RECORD(DECL_UPDATES); RECORD(CXX_BASE_SPECIFIER_OFFSETS); RECORD(DIAG_PRAGMA_MAPPINGS); RECORD(CUDA_SPECIAL_DECL_REFS); RECORD(HEADER_SEARCH_TABLE); RECORD(FP_PRAGMA_OPTIONS); RECORD(OPENCL_EXTENSIONS); RECORD(DELEGATING_CTORS); RECORD(KNOWN_NAMESPACES); RECORD(UNDEFINED_BUT_USED); RECORD(MODULE_OFFSET_MAP); RECORD(SOURCE_MANAGER_LINE_TABLE); RECORD(OBJC_CATEGORIES_MAP); RECORD(FILE_SORTED_DECLS); RECORD(IMPORTED_MODULES); RECORD(MERGED_DECLARATIONS); RECORD(LOCAL_REDECLARATIONS); RECORD(OBJC_CATEGORIES); RECORD(MACRO_OFFSET); RECORD(MACRO_TABLE); RECORD(LATE_PARSED_TEMPLATE); // SourceManager Block. BLOCK(SOURCE_MANAGER_BLOCK); RECORD(SM_SLOC_FILE_ENTRY); RECORD(SM_SLOC_BUFFER_ENTRY); RECORD(SM_SLOC_BUFFER_BLOB); RECORD(SM_SLOC_EXPANSION_ENTRY); // Preprocessor Block. BLOCK(PREPROCESSOR_BLOCK); RECORD(PP_MACRO_OBJECT_LIKE); RECORD(PP_MACRO_FUNCTION_LIKE); RECORD(PP_TOKEN); // Decls and Types block. BLOCK(DECLTYPES_BLOCK); RECORD(TYPE_EXT_QUAL); RECORD(TYPE_COMPLEX); RECORD(TYPE_POINTER); RECORD(TYPE_BLOCK_POINTER); RECORD(TYPE_LVALUE_REFERENCE); RECORD(TYPE_RVALUE_REFERENCE); RECORD(TYPE_MEMBER_POINTER); RECORD(TYPE_CONSTANT_ARRAY); RECORD(TYPE_INCOMPLETE_ARRAY); RECORD(TYPE_VARIABLE_ARRAY); RECORD(TYPE_VECTOR); RECORD(TYPE_EXT_VECTOR); RECORD(TYPE_FUNCTION_PROTO); RECORD(TYPE_FUNCTION_NO_PROTO); RECORD(TYPE_TYPEDEF); RECORD(TYPE_TYPEOF_EXPR); RECORD(TYPE_TYPEOF); RECORD(TYPE_RECORD); RECORD(TYPE_ENUM); RECORD(TYPE_OBJC_INTERFACE); RECORD(TYPE_OBJC_OBJECT); RECORD(TYPE_OBJC_OBJECT_POINTER); RECORD(TYPE_DECLTYPE); RECORD(TYPE_ELABORATED); RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM); RECORD(TYPE_UNRESOLVED_USING); RECORD(TYPE_INJECTED_CLASS_NAME); RECORD(TYPE_OBJC_OBJECT); RECORD(TYPE_TEMPLATE_TYPE_PARM); RECORD(TYPE_TEMPLATE_SPECIALIZATION); RECORD(TYPE_DEPENDENT_NAME); RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION); RECORD(TYPE_DEPENDENT_SIZED_ARRAY); RECORD(TYPE_PAREN); RECORD(TYPE_PACK_EXPANSION); RECORD(TYPE_ATTRIBUTED); RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK); RECORD(TYPE_ATOMIC); RECORD(DECL_TYPEDEF); RECORD(DECL_ENUM); RECORD(DECL_RECORD); RECORD(DECL_ENUM_CONSTANT); RECORD(DECL_FUNCTION); RECORD(DECL_OBJC_METHOD); RECORD(DECL_OBJC_INTERFACE); RECORD(DECL_OBJC_PROTOCOL); RECORD(DECL_OBJC_IVAR); RECORD(DECL_OBJC_AT_DEFS_FIELD); RECORD(DECL_OBJC_CATEGORY); RECORD(DECL_OBJC_CATEGORY_IMPL); RECORD(DECL_OBJC_IMPLEMENTATION); RECORD(DECL_OBJC_COMPATIBLE_ALIAS); RECORD(DECL_OBJC_PROPERTY); RECORD(DECL_OBJC_PROPERTY_IMPL); RECORD(DECL_FIELD); RECORD(DECL_MS_PROPERTY); RECORD(DECL_VAR); RECORD(DECL_IMPLICIT_PARAM); RECORD(DECL_PARM_VAR); RECORD(DECL_FILE_SCOPE_ASM); RECORD(DECL_BLOCK); RECORD(DECL_CONTEXT_LEXICAL); RECORD(DECL_CONTEXT_VISIBLE); RECORD(DECL_NAMESPACE); RECORD(DECL_NAMESPACE_ALIAS); RECORD(DECL_USING); RECORD(DECL_USING_SHADOW); RECORD(DECL_USING_DIRECTIVE); RECORD(DECL_UNRESOLVED_USING_VALUE); RECORD(DECL_UNRESOLVED_USING_TYPENAME); RECORD(DECL_LINKAGE_SPEC); RECORD(DECL_CXX_RECORD); RECORD(DECL_CXX_METHOD); RECORD(DECL_CXX_CONSTRUCTOR); RECORD(DECL_CXX_DESTRUCTOR); RECORD(DECL_CXX_CONVERSION); RECORD(DECL_ACCESS_SPEC); RECORD(DECL_FRIEND); RECORD(DECL_FRIEND_TEMPLATE); RECORD(DECL_CLASS_TEMPLATE); RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION); RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION); RECORD(DECL_VAR_TEMPLATE); RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION); RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION); RECORD(DECL_FUNCTION_TEMPLATE); RECORD(DECL_TEMPLATE_TYPE_PARM); RECORD(DECL_NON_TYPE_TEMPLATE_PARM); RECORD(DECL_TEMPLATE_TEMPLATE_PARM); RECORD(DECL_STATIC_ASSERT); RECORD(DECL_CXX_BASE_SPECIFIERS); RECORD(DECL_INDIRECTFIELD); RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK); // Statements and Exprs can occur in the Decls and Types block. AddStmtsExprs(Stream, Record); BLOCK(PREPROCESSOR_DETAIL_BLOCK); RECORD(PPD_MACRO_EXPANSION); RECORD(PPD_MACRO_DEFINITION); RECORD(PPD_INCLUSION_DIRECTIVE); #undef RECORD #undef BLOCK Stream.ExitBlock(); } /// \brief Adjusts the given filename to only write out the portion of the /// filename that is not part of the system root directory. /// /// \param Filename the file name to adjust. /// /// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and /// the returned filename will be adjusted by this system root. /// /// \returns either the original filename (if it needs no adjustment) or the /// adjusted filename (which points into the @@p Filename parameter). static const char * adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) { assert(Filename && "No file name to adjust?"); if (isysroot.empty()) return Filename; // Verify that the filename and the system root have the same prefix. unsigned Pos = 0; for (; Filename[Pos] && Pos < isysroot.size(); ++Pos) if (Filename[Pos] != isysroot[Pos]) return Filename; // Prefixes don't match. // We hit the end of the filename before we hit the end of the system root. if (!Filename[Pos]) return Filename; // If the file name has a '/' at the current position, skip over the '/'. // We distinguish sysroot-based includes from absolute includes by the // absence of '/' at the beginning of sysroot-based includes. if (Filename[Pos] == '/') ++Pos; return Filename + Pos; } /// \brief Write the control block. void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, StringRef isysroot, const std::string &OutputFile) { using namespace llvm; Stream.EnterSubblock(CONTROL_BLOCK_ID, 5); RecordData Record; // Metadata BitCodeAbbrev *MetadataAbbrev = new BitCodeAbbrev(); MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA)); MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj. MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min. MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev); Record.push_back(METADATA); Record.push_back(VERSION_MAJOR); Record.push_back(VERSION_MINOR); Record.push_back(CLANG_VERSION_MAJOR); Record.push_back(CLANG_VERSION_MINOR); Record.push_back(!isysroot.empty()); Record.push_back(ASTHasCompilerErrors); Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, getClangFullRepositoryVersion()); // Imports if (Chain) { serialization::ModuleManager &Mgr = Chain->getModuleManager(); Record.clear(); for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end(); M != MEnd; ++M) { // Skip modules that weren't directly imported. if (!(*M)->isDirectlyImported()) continue; Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding AddSourceLocation((*M)->ImportLoc, Record); Record.push_back((*M)->File->getSize()); Record.push_back((*M)->File->getModificationTime()); // FIXME: This writes the absolute path for AST files we depend on. const std::string &FileName = (*M)->FileName; Record.push_back(FileName.size()); Record.append(FileName.begin(), FileName.end()); } Stream.EmitRecord(IMPORTS, Record); } // Language options. Record.clear(); const LangOptions &LangOpts = Context.getLangOpts(); #define LANGOPT(Name, Bits, Default, Description) \ Record.push_back(LangOpts.Name); #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ Record.push_back(static_cast(LangOpts.get##Name())); #include "clang/Basic/LangOptions.def" #define SANITIZER(NAME, ID) Record.push_back(LangOpts.Sanitize.ID); #include "clang/Basic/Sanitizers.def" Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind()); AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record); Record.push_back(LangOpts.CurrentModule.size()); Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end()); // Comment options. Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size()); for (CommentOptions::BlockCommandNamesTy::const_iterator I = LangOpts.CommentOpts.BlockCommandNames.begin(), IEnd = LangOpts.CommentOpts.BlockCommandNames.end(); I != IEnd; ++I) { AddString(*I, Record); } Record.push_back(LangOpts.CommentOpts.ParseAllComments); Stream.EmitRecord(LANGUAGE_OPTIONS, Record); // Target options. Record.clear(); const TargetInfo &Target = Context.getTargetInfo(); const TargetOptions &TargetOpts = Target.getTargetOpts(); AddString(TargetOpts.Triple, Record); AddString(TargetOpts.CPU, Record); AddString(TargetOpts.ABI, Record); AddString(TargetOpts.LinkerVersion, Record); Record.push_back(TargetOpts.FeaturesAsWritten.size()); for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) { AddString(TargetOpts.FeaturesAsWritten[I], Record); } Record.push_back(TargetOpts.Features.size()); for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) { AddString(TargetOpts.Features[I], Record); } Stream.EmitRecord(TARGET_OPTIONS, Record); // Diagnostic options. Record.clear(); const DiagnosticOptions &DiagOpts = Context.getDiagnostics().getDiagnosticOptions(); #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name); #define ENUM_DIAGOPT(Name, Type, Bits, Default) \ Record.push_back(static_cast(DiagOpts.get##Name())); #include "clang/Basic/DiagnosticOptions.def" Record.push_back(DiagOpts.Warnings.size()); for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I) AddString(DiagOpts.Warnings[I], Record); // Note: we don't serialize the log or serialization file names, because they // are generally transient files and will almost always be overridden. Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record); // File system options. Record.clear(); const FileSystemOptions &FSOpts = Context.getSourceManager().getFileManager().getFileSystemOptions(); AddString(FSOpts.WorkingDir, Record); Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record); // Header search options. Record.clear(); const HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); AddString(HSOpts.Sysroot, Record); // Include entries. Record.push_back(HSOpts.UserEntries.size()); for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) { const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I]; AddString(Entry.Path, Record); Record.push_back(static_cast(Entry.Group)); Record.push_back(Entry.IsFramework); Record.push_back(Entry.IgnoreSysRoot); } // System header prefixes. Record.push_back(HSOpts.SystemHeaderPrefixes.size()); for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) { AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record); Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader); } AddString(HSOpts.ResourceDir, Record); AddString(HSOpts.ModuleCachePath, Record); Record.push_back(HSOpts.DisableModuleHash); Record.push_back(HSOpts.UseBuiltinIncludes); Record.push_back(HSOpts.UseStandardSystemIncludes); Record.push_back(HSOpts.UseStandardCXXIncludes); Record.push_back(HSOpts.UseLibcxx); Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record); // Preprocessor options. Record.clear(); const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts(); // Macro definitions. Record.push_back(PPOpts.Macros.size()); for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { AddString(PPOpts.Macros[I].first, Record); Record.push_back(PPOpts.Macros[I].second); } // Includes Record.push_back(PPOpts.Includes.size()); for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I) AddString(PPOpts.Includes[I], Record); // Macro includes Record.push_back(PPOpts.MacroIncludes.size()); for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I) AddString(PPOpts.MacroIncludes[I], Record); Record.push_back(PPOpts.UsePredefines); // Detailed record is important since it is used for the module cache hash. Record.push_back(PPOpts.DetailedRecord); AddString(PPOpts.ImplicitPCHInclude, Record); AddString(PPOpts.ImplicitPTHInclude, Record); Record.push_back(static_cast(PPOpts.ObjCXXARCStandardLibrary)); Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record); // Original file name and file ID SourceManager &SM = Context.getSourceManager(); if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev(); FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE)); FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); SmallString<128> MainFilePath(MainFile->getName()); llvm::sys::fs::make_absolute(MainFilePath); const char *MainFileNameStr = MainFilePath.c_str(); MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, isysroot); Record.clear(); Record.push_back(ORIGINAL_FILE); Record.push_back(SM.getMainFileID().getOpaqueValue()); Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr); } Record.clear(); Record.push_back(SM.getMainFileID().getOpaqueValue()); Stream.EmitRecord(ORIGINAL_FILE_ID, Record); // Original PCH directory if (!OutputFile.empty() && OutputFile != "-") { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); SmallString<128> OutputPath(OutputFile); llvm::sys::fs::make_absolute(OutputPath); StringRef origDir = llvm::sys::path::parent_path(OutputPath); RecordData Record; Record.push_back(ORIGINAL_PCH_DIR); Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); } WriteInputFiles(Context.SourceMgr, PP.getHeaderSearchInfo().getHeaderSearchOpts(), isysroot, PP.getLangOpts().Modules); Stream.ExitBlock(); } namespace { /// \brief An input file. struct InputFileEntry { const FileEntry *File; bool IsSystemFile; bool BufferOverridden; }; } void ASTWriter::WriteInputFiles(SourceManager &SourceMgr, HeaderSearchOptions &HSOpts, StringRef isysroot, bool Modules) { using namespace llvm; Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4); RecordData Record; // Create input-file abbreviation. BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev(); IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE)); IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev); // Get all ContentCache objects for files, sorted by whether the file is a // system one or not. System files go at the back, users files at the front. std::deque SortedFiles; for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { // Get this source location entry. const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc); // We only care about file entries that were not overridden. if (!SLoc->isFile()) continue; const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); if (!Cache->OrigEntry) continue; InputFileEntry Entry; Entry.File = Cache->OrigEntry; Entry.IsSystemFile = Cache->IsSystemFile; Entry.BufferOverridden = Cache->BufferOverridden; if (Cache->IsSystemFile) SortedFiles.push_back(Entry); else SortedFiles.push_front(Entry); } // If we have an isysroot for a Darwin SDK, include its SDKSettings.plist in // the set of (non-system) input files. This is simple heuristic for // detecting whether the system headers may have changed, because it is too // expensive to stat() all of the system headers. FileManager &FileMgr = SourceMgr.getFileManager(); if (!HSOpts.Sysroot.empty() && !Chain) { llvm::SmallString<128> SDKSettingsFileName(HSOpts.Sysroot); llvm::sys::path::append(SDKSettingsFileName, "SDKSettings.plist"); if (const FileEntry *SDKSettingsFile = FileMgr.getFile(SDKSettingsFileName)) { InputFileEntry Entry = { SDKSettingsFile, false, false }; SortedFiles.push_front(Entry); } } // Add the compiler's own module.map in the set of (non-system) input files. // This is a simple heuristic for detecting whether the compiler's headers // have changed, because we don't want to stat() all of them. if (Modules && !Chain) { SmallString<128> P = StringRef(HSOpts.ResourceDir); llvm::sys::path::append(P, "include"); llvm::sys::path::append(P, "module.map"); if (const FileEntry *ModuleMapFile = FileMgr.getFile(P)) { InputFileEntry Entry = { ModuleMapFile, false, false }; SortedFiles.push_front(Entry); } } unsigned UserFilesNum = 0; // Write out all of the input files. std::vector InputFileOffsets; for (std::deque::iterator I = SortedFiles.begin(), E = SortedFiles.end(); I != E; ++I) { const InputFileEntry &Entry = *I; uint32_t &InputFileID = InputFileIDs[Entry.File]; if (InputFileID != 0) continue; // already recorded this file. // Record this entry's offset. InputFileOffsets.push_back(Stream.GetCurrentBitNo()); InputFileID = InputFileOffsets.size(); if (!Entry.IsSystemFile) ++UserFilesNum; Record.clear(); Record.push_back(INPUT_FILE); Record.push_back(InputFileOffsets.size()); // Emit size/modification time for this file. Record.push_back(Entry.File->getSize()); Record.push_back(Entry.File->getModificationTime()); // Whether this file was overridden. Record.push_back(Entry.BufferOverridden); // Turn the file name into an absolute path, if it isn't already. const char *Filename = Entry.File->getName(); SmallString<128> FilePath(Filename); // Ask the file manager to fixup the relative path for us. This will // honor the working directory. FileMgr.FixupRelativePath(FilePath); // FIXME: This call to make_absolute shouldn't be necessary, the // call to FixupRelativePath should always return an absolute path. llvm::sys::fs::make_absolute(FilePath); Filename = FilePath.c_str(); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); Stream.EmitRecordWithBlob(IFAbbrevCode, Record, Filename); } Stream.ExitBlock(); // Create input file offsets abbreviation. BitCodeAbbrev *OffsetsAbbrev = new BitCodeAbbrev(); OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS)); OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system // input files OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev); // Write input file offsets. Record.clear(); Record.push_back(INPUT_FILE_OFFSETS); Record.push_back(InputFileOffsets.size()); Record.push_back(UserFilesNum); Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, data(InputFileOffsets)); } //===----------------------------------------------------------------------===// // Source Manager Serialization //===----------------------------------------------------------------------===// /// \brief Create an abbreviation for the SLocEntry that refers to a /// file. static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives // FileEntry fields. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer. static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer's blob. static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a macro /// expansion. static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length return Stream.EmitAbbrev(Abbrev); } namespace { // Trait used for the on-disk hash table of header search information. class HeaderFileInfoTrait { ASTWriter &Writer; const HeaderSearch &HS; // Keep track of the framework names we've used during serialization. SmallVector FrameworkStringData; llvm::StringMap FrameworkNameOffset; public: HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS) : Writer(Writer), HS(HS) { } struct key_type { const FileEntry *FE; const char *Filename; }; typedef const key_type &key_type_ref; typedef HeaderFileInfo data_type; typedef const data_type &data_type_ref; static unsigned ComputeHash(key_type_ref key) { // The hash is based only on size/time of the file, so that the reader can // match even when symlinking or excess path elements ("foo/../", "../") // change the form of the name. However, complete path is still the key. return llvm::hash_combine(key.FE->getSize(), key.FE->getModificationTime()); } std::pair EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) { unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8; clang::io::Emit16(Out, KeyLen); unsigned DataLen = 1 + 2 + 4 + 4; if (Data.isModuleHeader) DataLen += 4; clang::io::Emit8(Out, DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) { clang::io::Emit64(Out, key.FE->getSize()); KeyLen -= 8; clang::io::Emit64(Out, key.FE->getModificationTime()); KeyLen -= 8; Out.write(key.Filename, KeyLen); } void EmitData(raw_ostream &Out, key_type_ref key, data_type_ref Data, unsigned DataLen) { using namespace clang::io; uint64_t Start = Out.tell(); (void)Start; unsigned char Flags = (Data.HeaderRole << 6) | (Data.isImport << 5) | (Data.isPragmaOnce << 4) | (Data.DirInfo << 2) | (Data.Resolved << 1) | Data.IndexHeaderMapHeader; Emit8(Out, (uint8_t)Flags); Emit16(Out, (uint16_t) Data.NumIncludes); if (!Data.ControllingMacro) Emit32(Out, (uint32_t)Data.ControllingMacroID); else Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro)); unsigned Offset = 0; if (!Data.Framework.empty()) { // If this header refers into a framework, save the framework name. llvm::StringMap::iterator Pos = FrameworkNameOffset.find(Data.Framework); if (Pos == FrameworkNameOffset.end()) { Offset = FrameworkStringData.size() + 1; FrameworkStringData.append(Data.Framework.begin(), Data.Framework.end()); FrameworkStringData.push_back(0); FrameworkNameOffset[Data.Framework] = Offset; } else Offset = Pos->second; } Emit32(Out, Offset); if (Data.isModuleHeader) { Module *Mod = HS.findModuleForHeader(key.FE).getModule(); Emit32(Out, Writer.getExistingSubmoduleID(Mod)); } assert(Out.tell() - Start == DataLen && "Wrong data length"); } const char *strings_begin() const { return FrameworkStringData.begin(); } const char *strings_end() const { return FrameworkStringData.end(); } }; } // end anonymous namespace /// \brief Write the header search block for the list of files that /// /// \param HS The header search structure to save. void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) { SmallVector FilesByUID; HS.getFileMgr().GetUniqueIDMapping(FilesByUID); if (FilesByUID.size() > HS.header_file_size()) FilesByUID.resize(HS.header_file_size()); HeaderFileInfoTrait GeneratorTrait(*this, HS); OnDiskChainedHashTableGenerator Generator; SmallVector SavedStrings; unsigned NumHeaderSearchEntries = 0; for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { const FileEntry *File = FilesByUID[UID]; if (!File) continue; // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo // from the external source if it was not provided already. const HeaderFileInfo &HFI = HS.getFileInfo(File); if (HFI.External && Chain) continue; if (HFI.isModuleHeader && !HFI.isCompilingModuleHeader) continue; // Turn the file name into an absolute path, if it isn't already. const char *Filename = File->getName(); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); // If we performed any translation on the file name at all, we need to // save this string, since the generator will refer to it later. if (Filename != File->getName()) { Filename = strdup(Filename); SavedStrings.push_back(Filename); } HeaderFileInfoTrait::key_type key = { File, Filename }; Generator.insert(key, HFI, GeneratorTrait); ++NumHeaderSearchEntries; } // Create the on-disk hash table in a buffer. SmallString<4096> TableData; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(TableData); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, GeneratorTrait); } // Create a blob abbreviation using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); // Write the header search table RecordData Record; Record.push_back(HEADER_SEARCH_TABLE); Record.push_back(BucketOffset); Record.push_back(NumHeaderSearchEntries); Record.push_back(TableData.size()); TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str()); // Free all of the strings we had to duplicate. for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) free(const_cast(SavedStrings[I])); } /// \brief Writes the block containing the serialized form of the /// source manager. /// /// TODO: We should probably use an on-disk hash table (stored in a /// blob), indexed based on the file name, so that we only create /// entries for files that we actually need. In the common case (no /// errors), we probably won't have to create file entries for any of /// the files in the AST. void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, const Preprocessor &PP, StringRef isysroot) { RecordData Record; // Enter the source manager block. Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3); // Abbreviations for the various kinds of source-location entries. unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream); // Write out the source location entry table. We skip the first // entry, which is always the same dummy entry. std::vector SLocEntryOffsets; RecordData PreloadSLocs; SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1); for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { // Get this source location entry. const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); FileID FID = FileID::get(I); assert(&SourceMgr.getSLocEntry(FID) == SLoc); // Record the offset of this source-location entry. SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); // Figure out which record code to use. unsigned Code; if (SLoc->isFile()) { const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); if (Cache->OrigEntry) { Code = SM_SLOC_FILE_ENTRY; } else Code = SM_SLOC_BUFFER_ENTRY; } else Code = SM_SLOC_EXPANSION_ENTRY; Record.clear(); Record.push_back(Code); // Starting offset of this entry within this module, so skip the dummy. Record.push_back(SLoc->getOffset() - 2); if (SLoc->isFile()) { const SrcMgr::FileInfo &File = SLoc->getFile(); Record.push_back(File.getIncludeLoc().getRawEncoding()); Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding Record.push_back(File.hasLineDirectives()); const SrcMgr::ContentCache *Content = File.getContentCache(); if (Content->OrigEntry) { assert(Content->OrigEntry == Content->ContentsEntry && "Writing to AST an overridden file is not supported"); // The source location entry is a file. Emit input file ID. assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry"); Record.push_back(InputFileIDs[Content->OrigEntry]); Record.push_back(File.NumCreatedFIDs); FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID); if (FDI != FileDeclIDs.end()) { Record.push_back(FDI->second->FirstDeclIndex); Record.push_back(FDI->second->DeclIDs.size()); } else { Record.push_back(0); Record.push_back(0); } Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record); if (Content->BufferOverridden) { Record.clear(); Record.push_back(SM_SLOC_BUFFER_BLOB); const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, StringRef(Buffer->getBufferStart(), Buffer->getBufferSize() + 1)); } } else { // The source location entry is a buffer. The blob associated // with this entry contains the contents of the buffer. // We add one to the size so that we capture the trailing NULL // that is required by llvm::MemoryBuffer::getMemBuffer (on // the reader side). const llvm::MemoryBuffer *Buffer = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); const char *Name = Buffer->getBufferIdentifier(); Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, StringRef(Name, strlen(Name) + 1)); Record.clear(); Record.push_back(SM_SLOC_BUFFER_BLOB); Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, StringRef(Buffer->getBufferStart(), Buffer->getBufferSize() + 1)); if (strcmp(Name, "") == 0) { PreloadSLocs.push_back(SLocEntryOffsets.size()); } } } else { // The source location entry is a macro expansion. const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); Record.push_back(Expansion.getSpellingLoc().getRawEncoding()); Record.push_back(Expansion.getExpansionLocStart().getRawEncoding()); Record.push_back(Expansion.isMacroArgExpansion() ? 0 : Expansion.getExpansionLocEnd().getRawEncoding()); // Compute the token length for this macro expansion. unsigned NextOffset = SourceMgr.getNextLocalOffset(); if (I + 1 != N) NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset(); Record.push_back(NextOffset - SLoc->getOffset() - 1); Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record); } } Stream.ExitBlock(); if (SLocEntryOffsets.empty()) return; // Write the source-location offsets table into the AST block. This // table is used for lazily loading source-location information. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(SOURCE_LOCATION_OFFSETS); Record.push_back(SLocEntryOffsets.size()); Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets)); // Write the source location entry preloads array, telling the AST // reader which source locations entries it should load eagerly. Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); // Write the line table. It depends on remapping working, so it must come // after the source location offsets. if (SourceMgr.hasLineTable()) { LineTableInfo &LineTable = SourceMgr.getLineTable(); Record.clear(); // Emit the file names Record.push_back(LineTable.getNumFilenames()); for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) { // Emit the file name const char *Filename = LineTable.getFilename(I); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); unsigned FilenameLen = Filename? strlen(Filename) : 0; Record.push_back(FilenameLen); if (FilenameLen) Record.insert(Record.end(), Filename, Filename + FilenameLen); } // Emit the line entries for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); L != LEnd; ++L) { // Only emit entries for local files. if (L->first.ID < 0) continue; // Emit the file ID Record.push_back(L->first.ID); // Emit the line entries Record.push_back(L->second.size()); for (std::vector::iterator LE = L->second.begin(), LEEnd = L->second.end(); LE != LEEnd; ++LE) { Record.push_back(LE->FileOffset); Record.push_back(LE->LineNo); Record.push_back(LE->FilenameID); Record.push_back((unsigned)LE->FileKind); Record.push_back(LE->IncludeOffset); } } Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record); } } //===----------------------------------------------------------------------===// // Preprocessor Serialization //===----------------------------------------------------------------------===// namespace { class ASTMacroTableTrait { public: typedef IdentID key_type; typedef key_type key_type_ref; struct Data { uint32_t MacroDirectivesOffset; }; typedef Data data_type; typedef const data_type &data_type_ref; static unsigned ComputeHash(IdentID IdID) { return llvm::hash_value(IdID); } std::pair static EmitKeyDataLength(raw_ostream& Out, key_type_ref Key, data_type_ref Data) { unsigned KeyLen = 4; // IdentID. unsigned DataLen = 4; // MacroDirectivesOffset. return std::make_pair(KeyLen, DataLen); } static void EmitKey(raw_ostream& Out, key_type_ref Key, unsigned KeyLen) { clang::io::Emit32(Out, Key); } static void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data, unsigned) { clang::io::Emit32(Out, Data.MacroDirectivesOffset); } }; } // end anonymous namespace static int compareMacroDirectives( const std::pair *X, const std::pair *Y) { return X->first->getName().compare(Y->first->getName()); } static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule, const Preprocessor &PP) { if (MacroInfo *MI = MD->getMacroInfo()) if (MI->isBuiltinMacro()) return true; if (IsModule) { SourceLocation Loc = MD->getLocation(); if (Loc.isInvalid()) return true; if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID()) return true; } return false; } /// \brief Writes the block containing the serialized form of the /// preprocessor. /// void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); if (PPRec) WritePreprocessorDetail(*PPRec); RecordData Record; // If the preprocessor __COUNTER__ value has been bumped, remember it. if (PP.getCounterValue() != 0) { Record.push_back(PP.getCounterValue()); Stream.EmitRecord(PP_COUNTER_VALUE, Record); Record.clear(); } // Enter the preprocessor block. Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); // If the AST file contains __DATE__ or __TIME__ emit a warning about this. // FIXME: use diagnostics subsystem for localization etc. if (PP.SawDateOrTime()) fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); // Loop over all the macro directives that are live at the end of the file, // emitting each to the PP section. // Construct the list of macro directives that need to be serialized. SmallVector, 2> MacroDirectives; for (Preprocessor::macro_iterator I = PP.macro_begin(/*IncludeExternalMacros=*/false), E = PP.macro_end(/*IncludeExternalMacros=*/false); I != E; ++I) { MacroDirectives.push_back(std::make_pair(I->first, I->second)); } // Sort the set of macro definitions that need to be serialized by the // name of the macro, to provide a stable ordering. llvm::array_pod_sort(MacroDirectives.begin(), MacroDirectives.end(), &compareMacroDirectives); OnDiskChainedHashTableGenerator Generator; // Emit the macro directives as a list and associate the offset with the // identifier they belong to. for (unsigned I = 0, N = MacroDirectives.size(); I != N; ++I) { const IdentifierInfo *Name = MacroDirectives[I].first; uint64_t MacroDirectiveOffset = Stream.GetCurrentBitNo(); MacroDirective *MD = MacroDirectives[I].second; // If the macro or identifier need no updates, don't write the macro history // for this one. // FIXME: Chain the macro history instead of re-writing it. if (MD->isFromPCH() && Name->isFromAST() && !Name->hasChangedSinceDeserialization()) continue; // Emit the macro directives in reverse source order. for (; MD; MD = MD->getPrevious()) { if (shouldIgnoreMacro(MD, IsModule, PP)) continue; AddSourceLocation(MD->getLocation(), Record); Record.push_back(MD->getKind()); if (DefMacroDirective *DefMD = dyn_cast(MD)) { MacroID InfoID = getMacroRef(DefMD->getInfo(), Name); Record.push_back(InfoID); Record.push_back(DefMD->isImported()); Record.push_back(DefMD->isAmbiguous()); } else if (VisibilityMacroDirective * VisMD = dyn_cast(MD)) { Record.push_back(VisMD->isPublic()); } } if (Record.empty()) continue; Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record); Record.clear(); IdentMacroDirectivesOffsetMap[Name] = MacroDirectiveOffset; IdentID NameID = getIdentifierRef(Name); ASTMacroTableTrait::Data data; data.MacroDirectivesOffset = MacroDirectiveOffset; Generator.insert(NameID, data); } /// \brief Offsets of each of the macros into the bitstream, indexed by /// the local macro ID /// /// For each identifier that is associated with a macro, this map /// provides the offset into the bitstream where that macro is /// defined. std::vector MacroOffsets; for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) { const IdentifierInfo *Name = MacroInfosToEmit[I].Name; MacroInfo *MI = MacroInfosToEmit[I].MI; MacroID ID = MacroInfosToEmit[I].ID; if (ID < FirstMacroID) { assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?"); continue; } // Record the local offset of this macro. unsigned Index = ID - FirstMacroID; if (Index == MacroOffsets.size()) MacroOffsets.push_back(Stream.GetCurrentBitNo()); else { if (Index > MacroOffsets.size()) MacroOffsets.resize(Index + 1); MacroOffsets[Index] = Stream.GetCurrentBitNo(); } AddIdentifierRef(Name, Record); Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc())); AddSourceLocation(MI->getDefinitionLoc(), Record); AddSourceLocation(MI->getDefinitionEndLoc(), Record); Record.push_back(MI->isUsed()); unsigned Code; if (MI->isObjectLike()) { Code = PP_MACRO_OBJECT_LIKE; } else { Code = PP_MACRO_FUNCTION_LIKE; Record.push_back(MI->isC99Varargs()); Record.push_back(MI->isGNUVarargs()); Record.push_back(MI->hasCommaPasting()); Record.push_back(MI->getNumArgs()); for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end(); I != E; ++I) AddIdentifierRef(*I, Record); } // If we have a detailed preprocessing record, record the macro definition // ID that corresponds to this macro. if (PPRec) Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]); Stream.EmitRecord(Code, Record); Record.clear(); // Emit the tokens array. for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { // Note that we know that the preprocessor does not have any annotation // tokens in it because they are created by the parser, and thus can't // be in a macro definition. const Token &Tok = MI->getReplacementToken(TokNo); AddToken(Tok, Record); Stream.EmitRecord(PP_TOKEN, Record); Record.clear(); } ++NumMacros; } Stream.ExitBlock(); // Create the on-disk hash table in a buffer. SmallString<4096> MacroTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(MacroTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out); } // Write the macro table using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MACRO_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MacroTableAbbrev = Stream.EmitAbbrev(Abbrev); Record.push_back(MACRO_TABLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(MacroTableAbbrev, Record, MacroTable.str()); Record.clear(); // Write the offsets table for macro IDs. using namespace llvm; Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(MACRO_OFFSET); Record.push_back(MacroOffsets.size()); Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS); Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, data(MacroOffsets)); } void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { if (PPRec.local_begin() == PPRec.local_end()) return; SmallVector PreprocessedEntityOffsets; // Enter the preprocessor block. Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); // If the preprocessor has a preprocessing record, emit it. unsigned NumPreprocessingRecords = 0; using namespace llvm; // Set up the abbreviation for unsigned InclusionAbbrev = 0; { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); InclusionAbbrev = Stream.EmitAbbrev(Abbrev); } unsigned FirstPreprocessorEntityID = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) + NUM_PREDEF_PP_ENTITY_IDS; unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; RecordData Record; for (PreprocessingRecord::iterator E = PPRec.local_begin(), EEnd = PPRec.local_end(); E != EEnd; (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { Record.clear(); PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo())); if (MacroDefinition *MD = dyn_cast(*E)) { // Record this macro definition's ID. MacroDefinitions[MD] = NextPreprocessorEntityID; AddIdentifierRef(MD->getName(), Record); Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); continue; } if (MacroExpansion *ME = dyn_cast(*E)) { Record.push_back(ME->isBuiltinMacro()); if (ME->isBuiltinMacro()) AddIdentifierRef(ME->getName(), Record); else Record.push_back(MacroDefinitions[ME->getDefinition()]); Stream.EmitRecord(PPD_MACRO_EXPANSION, Record); continue; } if (InclusionDirective *ID = dyn_cast(*E)) { Record.push_back(PPD_INCLUSION_DIRECTIVE); Record.push_back(ID->getFileName().size()); Record.push_back(ID->wasInQuotes()); Record.push_back(static_cast(ID->getKind())); Record.push_back(ID->importedModule()); SmallString<64> Buffer; Buffer += ID->getFileName(); // Check that the FileEntry is not null because it was not resolved and // we create a PCH even with compiler errors. if (ID->getFile()) Buffer += ID->getFile()->getName(); Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); continue; } llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); } Stream.ExitBlock(); // Write the offsets table for the preprocessing record. if (NumPreprocessingRecords > 0) { assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords); // Write the offsets table for identifier IDs. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(PPD_ENTITIES_OFFSETS); Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS); Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, data(PreprocessedEntityOffsets)); } } unsigned ASTWriter::getSubmoduleID(Module *Mod) { llvm::DenseMap::iterator Known = SubmoduleIDs.find(Mod); if (Known != SubmoduleIDs.end()) return Known->second; return SubmoduleIDs[Mod] = NextSubmoduleID++; } unsigned ASTWriter::getExistingSubmoduleID(Module *Mod) const { if (!Mod) return 0; llvm::DenseMap::const_iterator Known = SubmoduleIDs.find(Mod); if (Known != SubmoduleIDs.end()) return Known->second; return 0; } /// \brief Compute the number of modules within the given tree (including the /// given module). static unsigned getNumberOfModules(Module *Mod) { unsigned ChildModules = 0; for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) ChildModules += getNumberOfModules(*Sub); return ChildModules + 1; } void ASTWriter::WriteSubmodules(Module *WritingModule) { // Determine the dependencies of our module and each of it's submodules. // FIXME: This feels like it belongs somewhere else, but there are no // other consumers of this information. SourceManager &SrcMgr = PP->getSourceManager(); ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); for (ASTContext::import_iterator I = Context->local_import_begin(), IEnd = Context->local_import_end(); I != IEnd; ++I) { if (Module *ImportedFrom = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(), SrcMgr))) { ImportedFrom->Imports.push_back(I->getImportedModule()); } } // Enter the submodule description block. Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); // Write the abbreviations needed for the submodules block. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh... Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(Abbrev); Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev); // Write the submodule metadata block. RecordData Record; Record.push_back(getNumberOfModules(WritingModule)); Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS); Stream.EmitRecord(SUBMODULE_METADATA, Record); // Write all of the submodules. std::queue Q; Q.push(WritingModule); while (!Q.empty()) { Module *Mod = Q.front(); Q.pop(); unsigned ID = getSubmoduleID(Mod); // Emit the definition of the block. Record.clear(); Record.push_back(SUBMODULE_DEFINITION); Record.push_back(ID); if (Mod->Parent) { assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); Record.push_back(SubmoduleIDs[Mod->Parent]); } else { Record.push_back(0); } Record.push_back(Mod->IsFramework); Record.push_back(Mod->IsExplicit); Record.push_back(Mod->IsSystem); Record.push_back(Mod->InferSubmodules); Record.push_back(Mod->InferExplicitSubmodules); Record.push_back(Mod->InferExportWildcard); Record.push_back(Mod->ConfigMacrosExhaustive); Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); // Emit the requirements. for (unsigned I = 0, N = Mod->Requirements.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_REQUIRES); Record.push_back(Mod->Requirements[I].second); Stream.EmitRecordWithBlob(RequiresAbbrev, Record, Mod->Requirements[I].first); } // Emit the umbrella header, if there is one. if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) { Record.clear(); Record.push_back(SUBMODULE_UMBRELLA_HEADER); Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, UmbrellaHeader->getName()); } else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) { Record.clear(); Record.push_back(SUBMODULE_UMBRELLA_DIR); Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, UmbrellaDir->getName()); } // Emit the headers. for (unsigned I = 0, N = Mod->NormalHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_HEADER); Stream.EmitRecordWithBlob(HeaderAbbrev, Record, Mod->NormalHeaders[I]->getName()); } // Emit the excluded headers. for (unsigned I = 0, N = Mod->ExcludedHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_EXCLUDED_HEADER); Stream.EmitRecordWithBlob(ExcludedHeaderAbbrev, Record, Mod->ExcludedHeaders[I]->getName()); } // Emit the private headers. for (unsigned I = 0, N = Mod->PrivateHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_PRIVATE_HEADER); Stream.EmitRecordWithBlob(PrivateHeaderAbbrev, Record, Mod->PrivateHeaders[I]->getName()); } ArrayRef TopHeaders = Mod->getTopHeaders(PP->getFileManager()); for (unsigned I = 0, N = TopHeaders.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_TOPHEADER); Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, TopHeaders[I]->getName()); } // Emit the imports. if (!Mod->Imports.empty()) { Record.clear(); for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { unsigned ImportedID = getSubmoduleID(Mod->Imports[I]); assert(ImportedID && "Unknown submodule!"); Record.push_back(ImportedID); } Stream.EmitRecord(SUBMODULE_IMPORTS, Record); } // Emit the exports. if (!Mod->Exports.empty()) { Record.clear(); for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { if (Module *Exported = Mod->Exports[I].getPointer()) { unsigned ExportedID = SubmoduleIDs[Exported]; assert(ExportedID > 0 && "Unknown submodule ID?"); Record.push_back(ExportedID); } else { Record.push_back(0); } Record.push_back(Mod->Exports[I].getInt()); } Stream.EmitRecord(SUBMODULE_EXPORTS, Record); } //FIXME: How do we emit the 'use'd modules? They may not be submodules. // Might be unnecessary as use declarations are only used to build the // module itself. // Emit the link libraries. for (unsigned I = 0, N = Mod->LinkLibraries.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_LINK_LIBRARY); Record.push_back(Mod->LinkLibraries[I].IsFramework); Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, Mod->LinkLibraries[I].Library); } // Emit the conflicts. for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_CONFLICT); unsigned OtherID = getSubmoduleID(Mod->Conflicts[I].Other); assert(OtherID && "Unknown submodule!"); Record.push_back(OtherID); Stream.EmitRecordWithBlob(ConflictAbbrev, Record, Mod->Conflicts[I].Message); } // Emit the configuration macros. for (unsigned I = 0, N = Mod->ConfigMacros.size(); I != N; ++I) { Record.clear(); Record.push_back(SUBMODULE_CONFIG_MACRO); Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, Mod->ConfigMacros[I]); } // Queue up the submodules of this module. for (Module::submodule_iterator Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); Sub != SubEnd; ++Sub) Q.push(*Sub); } Stream.ExitBlock(); assert((NextSubmoduleID - FirstSubmoduleID == getNumberOfModules(WritingModule)) && "Wrong # of submodules"); } serialization::SubmoduleID ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) { if (Loc.isInvalid() || !WritingModule) return 0; // No submodule // Find the module that owns this location. ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); Module *OwningMod = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager())); if (!OwningMod) return 0; // Check whether this submodule is part of our own module. if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule)) return 0; return getSubmoduleID(OwningMod); } void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag, bool isModule) { // Make sure set diagnostic pragmas don't affect the translation unit that // imports the module. // FIXME: Make diagnostic pragma sections work properly with modules. if (isModule) return; llvm::SmallDenseMap DiagStateIDMap; unsigned CurrID = 0; DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one. RecordData Record; for (DiagnosticsEngine::DiagStatePointsTy::const_iterator I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end(); I != E; ++I) { const DiagnosticsEngine::DiagStatePoint &point = *I; if (point.Loc.isInvalid()) continue; Record.push_back(point.Loc.getRawEncoding()); unsigned &DiagStateID = DiagStateIDMap[point.State]; Record.push_back(DiagStateID); if (DiagStateID == 0) { DiagStateID = ++CurrID; for (DiagnosticsEngine::DiagState::const_iterator I = point.State->begin(), E = point.State->end(); I != E; ++I) { if (I->second.isPragma()) { Record.push_back(I->first); Record.push_back(I->second.getMapping()); } } Record.push_back(-1); // mark the end of the diag/map pairs for this // location. } } if (!Record.empty()) Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); } void ASTWriter::WriteCXXBaseSpecifiersOffsets() { if (CXXBaseSpecifiersOffsets.empty()) return; RecordData Record; // Create a blob abbreviation for the C++ base specifiers offsets. using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); // Write the base specifier offsets table. Record.clear(); Record.push_back(CXX_BASE_SPECIFIER_OFFSETS); Record.push_back(CXXBaseSpecifiersOffsets.size()); Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record, data(CXXBaseSpecifiersOffsets)); } //===----------------------------------------------------------------------===// // Type Serialization //===----------------------------------------------------------------------===// /// \brief Write the representation of a type to the AST stream. void ASTWriter::WriteType(QualType T) { TypeIdx &Idx = TypeIdxs[T]; if (Idx.getIndex() == 0) // we haven't seen this type before. Idx = TypeIdx(NextTypeID++); assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); // Record the offset for this type. unsigned Index = Idx.getIndex() - FirstTypeID; if (TypeOffsets.size() == Index) TypeOffsets.push_back(Stream.GetCurrentBitNo()); else if (TypeOffsets.size() < Index) { TypeOffsets.resize(Index + 1); TypeOffsets[Index] = Stream.GetCurrentBitNo(); } RecordData Record; // Emit the type's representation. ASTTypeWriter W(*this, Record); if (T.hasLocalNonFastQualifiers()) { Qualifiers Qs = T.getLocalQualifiers(); AddTypeRef(T.getLocalUnqualifiedType(), Record); Record.push_back(Qs.getAsOpaqueValue()); W.Code = TYPE_EXT_QUAL; } else { switch (T->getTypeClass()) { // For all of the concrete, non-dependent types, call the // appropriate visitor function. #define TYPE(Class, Base) \ case Type::Class: W.Visit##Class##Type(cast(T)); break; #define ABSTRACT_TYPE(Class, Base) #include "clang/AST/TypeNodes.def" } } // Emit the serialized record. Stream.EmitRecord(W.Code, Record); // Flush any expressions that were written as part of this type. FlushStmts(); } //===----------------------------------------------------------------------===// // Declaration Serialization //===----------------------------------------------------------------------===// /// \brief Write the block containing all of the declaration IDs /// lexically declared within the given DeclContext. /// /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the /// bistream, or 0 if no block was written. uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, DeclContext *DC) { if (DC->decls_empty()) return 0; uint64_t Offset = Stream.GetCurrentBitNo(); RecordData Record; Record.push_back(DECL_CONTEXT_LEXICAL); SmallVector Decls; for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end(); D != DEnd; ++D) Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D))); ++NumLexicalDeclContexts; Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls)); return Offset; } void ASTWriter::WriteTypeDeclOffsets() { using namespace llvm; RecordData Record; // Write the type offsets array BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(TYPE_OFFSET); Record.push_back(TypeOffsets.size()); Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS); Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets)); // Write the declaration offsets array Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); Record.clear(); Record.push_back(DECL_OFFSET); Record.push_back(DeclOffsets.size()); Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS); Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets)); } void ASTWriter::WriteFileDeclIDsMap() { using namespace llvm; RecordData Record; // Join the vectors of DeclIDs from all files. SmallVector FileSortedIDs; for (FileDeclIDsTy::iterator FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) { DeclIDInFileInfo &Info = *FI->second; Info.FirstDeclIndex = FileSortedIDs.size(); for (LocDeclIDsTy::iterator DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI) FileSortedIDs.push_back(DI->second); } BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); Record.push_back(FILE_SORTED_DECLS); Record.push_back(FileSortedIDs.size()); Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs)); } void ASTWriter::WriteComments() { Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3); ArrayRef RawComments = Context->Comments.getComments(); RecordData Record; for (ArrayRef::iterator I = RawComments.begin(), E = RawComments.end(); I != E; ++I) { Record.clear(); AddSourceRange((*I)->getSourceRange(), Record); Record.push_back((*I)->getKind()); Record.push_back((*I)->isTrailingComment()); Record.push_back((*I)->isAlmostTrailingComment()); Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record); } Stream.ExitBlock(); } //===----------------------------------------------------------------------===// // Global Method Pool and Selector Serialization //===----------------------------------------------------------------------===// namespace { // Trait used for the on-disk hash table used in the method pool. class ASTMethodPoolTrait { ASTWriter &Writer; public: typedef Selector key_type; typedef key_type key_type_ref; struct data_type { SelectorID ID; ObjCMethodList Instance, Factory; }; typedef const data_type& data_type_ref; explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } static unsigned ComputeHash(Selector Sel) { return serialization::ComputeHash(Sel); } std::pair EmitKeyDataLength(raw_ostream& Out, Selector Sel, data_type_ref Methods) { unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); clang::io::Emit16(Out, KeyLen); unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) DataLen += 4; for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) DataLen += 4; clang::io::Emit16(Out, DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, Selector Sel, unsigned) { uint64_t Start = Out.tell(); assert((Start >> 32) == 0 && "Selector key offset too large"); Writer.SetSelectorOffset(Sel, Start); unsigned N = Sel.getNumArgs(); clang::io::Emit16(Out, N); if (N == 0) N = 1; for (unsigned I = 0; I != N; ++I) clang::io::Emit32(Out, Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); } void EmitData(raw_ostream& Out, key_type_ref, data_type_ref Methods, unsigned DataLen) { uint64_t Start = Out.tell(); (void)Start; clang::io::Emit32(Out, Methods.ID); unsigned NumInstanceMethods = 0; for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) ++NumInstanceMethods; unsigned NumFactoryMethods = 0; for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) ++NumFactoryMethods; unsigned InstanceBits = Methods.Instance.getBits(); assert(InstanceBits < 4); unsigned NumInstanceMethodsAndBits = (NumInstanceMethods << 2) | InstanceBits; unsigned FactoryBits = Methods.Factory.getBits(); assert(FactoryBits < 4); unsigned NumFactoryMethodsAndBits = (NumFactoryMethods << 2) | FactoryBits; clang::io::Emit16(Out, NumInstanceMethodsAndBits); clang::io::Emit16(Out, NumFactoryMethodsAndBits); for (const ObjCMethodList *Method = &Methods.Instance; Method; Method = Method->getNext()) if (Method->Method) clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); for (const ObjCMethodList *Method = &Methods.Factory; Method; Method = Method->getNext()) if (Method->Method) clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); assert(Out.tell() - Start == DataLen && "Data length is wrong"); } }; } // end anonymous namespace /// \brief Write ObjC data: selectors and the method pool. /// /// The method pool contains both instance and factory methods, stored /// in an on-disk hash table indexed by the selector. The hash table also /// contains an empty entry for every other selector known to Sema. void ASTWriter::WriteSelectors(Sema &SemaRef) { using namespace llvm; // Do we have to do anything at all? if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) return; unsigned NumTableEntries = 0; // Create and write out the blob that contains selectors and the method pool. { OnDiskChainedHashTableGenerator Generator; ASTMethodPoolTrait Trait(*this); // Create the on-disk hash table representation. We walk through every // selector we've seen and look it up in the method pool. SelectorOffsets.resize(NextSelectorID - FirstSelectorID); for (llvm::DenseMap::iterator I = SelectorIDs.begin(), E = SelectorIDs.end(); I != E; ++I) { Selector S = I->first; Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); ASTMethodPoolTrait::data_type Data = { I->second, ObjCMethodList(), ObjCMethodList() }; if (F != SemaRef.MethodPool.end()) { Data.Instance = F->second.first; Data.Factory = F->second.second; } // Only write this selector if it's not in an existing AST or something // changed. if (Chain && I->second < FirstSelectorID) { // Selector already exists. Did it change? bool changed = false; for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method; M = M->getNext()) { if (!M->Method->isFromASTFile()) changed = true; } for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method; M = M->getNext()) { if (!M->Method->isFromASTFile()) changed = true; } if (!changed) continue; } else if (Data.Instance.Method || Data.Factory.Method) { // A new method pool entry. ++NumTableEntries; } Generator.insert(S, Data, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> MethodPool; uint32_t BucketOffset; { ASTMethodPoolTrait Trait(*this); llvm::raw_svector_ostream Out(MethodPool); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Create a blob abbreviation BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); // Write the method pool RecordData Record; Record.push_back(METHOD_POOL); Record.push_back(BucketOffset); Record.push_back(NumTableEntries); Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str()); // Create a blob abbreviation for the selector table offsets. Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); // Write the selector offsets table. Record.clear(); Record.push_back(SELECTOR_OFFSETS); Record.push_back(SelectorOffsets.size()); Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS); Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, data(SelectorOffsets)); } } /// \brief Write the selectors referenced in @@selector expression into AST file. void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { using namespace llvm; if (SemaRef.ReferencedSelectors.empty()) return; RecordData Record; // Note: this writes out all references even for a dependent AST. But it is // very tricky to fix, and given that @@selector shouldn't really appear in // headers, probably not worth it. It's not a correctness issue. for (DenseMap::iterator S = SemaRef.ReferencedSelectors.begin(), E = SemaRef.ReferencedSelectors.end(); S != E; ++S) { Selector Sel = (*S).first; SourceLocation Loc = (*S).second; AddSelectorRef(Sel, Record); AddSourceLocation(Loc, Record); } Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record); } //===----------------------------------------------------------------------===// // Identifier Table Serialization //===----------------------------------------------------------------------===// namespace { class ASTIdentifierTableTrait { ASTWriter &Writer; Preprocessor &PP; IdentifierResolver &IdResolver; bool IsModule; /// \brief Determines whether this is an "interesting" identifier /// that needs a full IdentifierInfo structure written into the hash /// table. bool isInterestingIdentifier(IdentifierInfo *II, MacroDirective *&Macro) { if (II->isPoisoned() || II->isExtensionToken() || II->getObjCOrBuiltinID() || II->hasRevertedTokenIDToIdentifier() || II->getFETokenInfo()) return true; return hadMacroDefinition(II, Macro); } bool hadMacroDefinition(IdentifierInfo *II, MacroDirective *&Macro) { if (!II->hadMacroDefinition()) return false; if (Macro || (Macro = PP.getMacroDirectiveHistory(II))) { if (!IsModule) return !shouldIgnoreMacro(Macro, IsModule, PP); SubmoduleID ModID; if (getFirstPublicSubmoduleMacro(Macro, ModID)) return true; } return false; } typedef llvm::SmallVectorImpl OverriddenList; MacroDirective * getFirstPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID) { ModID = 0; llvm::SmallVector Overridden; if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD, ModID, Overridden)) if (!shouldIgnoreMacro(NextMD, IsModule, PP)) return NextMD; return 0; } MacroDirective * getNextPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID, OverriddenList &Overridden) { if (MacroDirective *NextMD = getPublicSubmoduleMacro(MD->getPrevious(), ModID, Overridden)) if (!shouldIgnoreMacro(NextMD, IsModule, PP)) return NextMD; return 0; } /// \brief Traverses the macro directives history and returns the latest /// public macro definition or undefinition that is not in ModID. /// A macro that is defined in submodule A and undefined in submodule B /// will still be considered as defined/exported from submodule A. /// ModID is updated to the module containing the returned directive. /// /// FIXME: This process breaks down if a module defines a macro, imports /// another submodule that changes the macro, then changes the /// macro again itself. MacroDirective *getPublicSubmoduleMacro(MacroDirective *MD, SubmoduleID &ModID, OverriddenList &Overridden) { if (!MD) return 0; Overridden.clear(); SubmoduleID OrigModID = ModID; Optional IsPublic; for (; MD; MD = MD->getPrevious()) { SubmoduleID ThisModID = getSubmoduleID(MD); if (ThisModID == 0) { IsPublic = Optional(); continue; } if (ThisModID != ModID) { ModID = ThisModID; IsPublic = Optional(); } // If this is a definition from a submodule import, that submodule's // definition is overridden by the definition or undefinition that we // started with. // FIXME: This should only apply to macros defined in OrigModID. // We can't do that currently, because a #include of a different submodule // of the same module just leaks through macros instead of providing new // DefMacroDirectives for them. if (DefMacroDirective *DefMD = dyn_cast(MD)) if (SubmoduleID SourceID = DefMD->getInfo()->getOwningModuleID()) Overridden.push_back(SourceID); // We are looking for a definition in a different submodule than the one // that we started with. If a submodule has re-definitions of the same // macro, only the last definition will be used as the "exported" one. if (ModID == OrigModID) continue; // The latest visibility directive for a name in a submodule affects all // the directives that come before it. if (VisibilityMacroDirective *VisMD = dyn_cast(MD)) { if (!IsPublic.hasValue()) IsPublic = VisMD->isPublic(); } else if (!IsPublic.hasValue() || IsPublic.getValue()) { // FIXME: If we find an imported macro, we should include its list of // overrides in our export. return MD; } } return 0; } SubmoduleID getSubmoduleID(MacroDirective *MD) { return Writer.inferSubmoduleIDFromLocation(MD->getLocation()); } public: typedef IdentifierInfo* key_type; typedef key_type key_type_ref; typedef IdentID data_type; typedef data_type data_type_ref; ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, IdentifierResolver &IdResolver, bool IsModule) : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { } static unsigned ComputeHash(const IdentifierInfo* II) { return llvm::HashString(II->getName()); } std::pair EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { unsigned KeyLen = II->getLength() + 1; unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 MacroDirective *Macro = 0; if (isInterestingIdentifier(II, Macro)) { DataLen += 2; // 2 bytes for builtin ID DataLen += 2; // 2 bytes for flags if (hadMacroDefinition(II, Macro)) { DataLen += 4; // MacroDirectives offset. if (IsModule) { SubmoduleID ModID; llvm::SmallVector Overridden; for (MacroDirective * MD = getFirstPublicSubmoduleMacro(Macro, ModID); MD; MD = getNextPublicSubmoduleMacro(MD, ModID, Overridden)) { // Previous macro's overrides. if (!Overridden.empty()) DataLen += 4 * (1 + Overridden.size()); DataLen += 4; // MacroInfo ID or ModuleID. } // Previous macro's overrides. if (!Overridden.empty()) DataLen += 4 * (1 + Overridden.size()); DataLen += 4; } } for (IdentifierResolver::iterator D = IdResolver.begin(II), DEnd = IdResolver.end(); D != DEnd; ++D) DataLen += sizeof(DeclID); } clang::io::Emit16(Out, DataLen); // We emit the key length after the data length so that every // string is preceded by a 16-bit length. This matches the PTH // format for storing identifiers. clang::io::Emit16(Out, KeyLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, const IdentifierInfo* II, unsigned KeyLen) { // Record the location of the key data. This is used when generating // the mapping from persistent IDs to strings. Writer.SetIdentifierOffset(II, Out.tell()); Out.write(II->getNameStart(), KeyLen); } static void emitMacroOverrides(raw_ostream &Out, llvm::ArrayRef Overridden) { if (!Overridden.empty()) { clang::io::Emit32(Out, Overridden.size() | 0x80000000U); for (unsigned I = 0, N = Overridden.size(); I != N; ++I) clang::io::Emit32(Out, Overridden[I]); } } void EmitData(raw_ostream& Out, IdentifierInfo* II, IdentID ID, unsigned) { MacroDirective *Macro = 0; if (!isInterestingIdentifier(II, Macro)) { clang::io::Emit32(Out, ID << 1); return; } clang::io::Emit32(Out, (ID << 1) | 0x01); uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID(); assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader."); clang::io::Emit16(Out, Bits); Bits = 0; bool HadMacroDefinition = hadMacroDefinition(II, Macro); Bits = (Bits << 1) | unsigned(HadMacroDefinition); Bits = (Bits << 1) | unsigned(IsModule); Bits = (Bits << 1) | unsigned(II->isExtensionToken()); Bits = (Bits << 1) | unsigned(II->isPoisoned()); Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); clang::io::Emit16(Out, Bits); if (HadMacroDefinition) { clang::io::Emit32(Out, Writer.getMacroDirectivesOffset(II)); if (IsModule) { // Write the IDs of macros coming from different submodules. SubmoduleID ModID; llvm::SmallVector Overridden; for (MacroDirective * MD = getFirstPublicSubmoduleMacro(Macro, ModID); MD; MD = getNextPublicSubmoduleMacro(MD, ModID, Overridden)) { MacroID InfoID = 0; emitMacroOverrides(Out, Overridden); if (DefMacroDirective *DefMD = dyn_cast(MD)) { InfoID = Writer.getMacroID(DefMD->getInfo()); assert(InfoID); clang::io::Emit32(Out, InfoID << 1); } else { assert(isa(MD)); clang::io::Emit32(Out, (ModID << 1) | 1); } } emitMacroOverrides(Out, Overridden); clang::io::Emit32(Out, 0); } } // Emit the declaration IDs in reverse order, because the // IdentifierResolver provides the declarations as they would be // visible (e.g., the function "stat" would come before the struct // "stat"), but the ASTReader adds declarations to the end of the list // (so we need to see the struct "status" before the function "status"). // Only emit declarations that aren't from a chained PCH, though. SmallVector Decls(IdResolver.begin(II), IdResolver.end()); for (SmallVectorImpl::reverse_iterator D = Decls.rbegin(), DEnd = Decls.rend(); D != DEnd; ++D) clang::io::Emit32(Out, Writer.getDeclID(getMostRecentLocalDecl(*D))); } /// \brief Returns the most recent local decl or the given decl if there are /// no local ones. The given decl is assumed to be the most recent one. Decl *getMostRecentLocalDecl(Decl *Orig) { // The only way a "from AST file" decl would be more recent from a local one // is if it came from a module. if (!PP.getLangOpts().Modules) return Orig; // Look for a local in the decl chain. for (Decl *D = Orig; D; D = D->getPreviousDecl()) { if (!D->isFromASTFile()) return D; // If we come up a decl from a (chained-)PCH stop since we won't find a // local one. if (D->getOwningModuleID() == 0) break; } return Orig; } }; } // end anonymous namespace /// \brief Write the identifier table into the AST file. /// /// The identifier table consists of a blob containing string data /// (the actual identifiers themselves) and a separate "offsets" index /// that maps identifier IDs to locations within the blob. void ASTWriter::WriteIdentifierTable(Preprocessor &PP, IdentifierResolver &IdResolver, bool IsModule) { using namespace llvm; // Create and write out the blob that contains the identifier // strings. { OnDiskChainedHashTableGenerator Generator; ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); // Look for any identifiers that were named while processing the // headers, but are otherwise not needed. We add these to the hash // table to enable checking of the predefines buffer in the case // where the user adds new macro definitions when building the AST // file. for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) getIdentifierRef(ID->second); // Create the on-disk hash table representation. We only store offsets // for identifiers that appear here for the first time. IdentifierOffsets.resize(NextIdentID - FirstIdentID); for (llvm::DenseMap::iterator ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); ID != IDEnd; ++ID) { assert(ID->first && "NULL identifier in identifier table"); if (!Chain || !ID->first->isFromAST() || ID->first->hasChangedSinceDeserialization()) Generator.insert(const_cast(ID->first), ID->second, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> IdentifierTable; uint32_t BucketOffset; { ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); llvm::raw_svector_ostream Out(IdentifierTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Create a blob abbreviation BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); // Write the identifier table RecordData Record; Record.push_back(IDENTIFIER_TABLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str()); } // Write the offsets table for identifier IDs. BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); #ifndef NDEBUG for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I) assert(IdentifierOffsets[I] && "Missing identifier offset?"); #endif RecordData Record; Record.push_back(IDENTIFIER_OFFSET); Record.push_back(IdentifierOffsets.size()); Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS); Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, data(IdentifierOffsets)); } //===----------------------------------------------------------------------===// // DeclContext's Name Lookup Table Serialization //===----------------------------------------------------------------------===// namespace { // Trait used for the on-disk hash table used in the method pool. class ASTDeclContextNameLookupTrait { ASTWriter &Writer; public: typedef DeclarationName key_type; typedef key_type key_type_ref; typedef DeclContext::lookup_result data_type; typedef const data_type& data_type_ref; explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { } unsigned ComputeHash(DeclarationName Name) { llvm::FoldingSetNodeID ID; ID.AddInteger(Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: ID.AddString(Name.getAsIdentifierInfo()->getName()); break; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector())); break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: break; case DeclarationName::CXXOperatorName: ID.AddInteger(Name.getCXXOverloadedOperator()); break; case DeclarationName::CXXLiteralOperatorName: ID.AddString(Name.getCXXLiteralIdentifier()->getName()); case DeclarationName::CXXUsingDirective: break; } return ID.ComputeHash(); } std::pair EmitKeyDataLength(raw_ostream& Out, DeclarationName Name, data_type_ref Lookup) { unsigned KeyLen = 1; switch (Name.getNameKind()) { case DeclarationName::Identifier: case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: case DeclarationName::CXXLiteralOperatorName: KeyLen += 4; break; case DeclarationName::CXXOperatorName: KeyLen += 1; break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: case DeclarationName::CXXUsingDirective: break; } clang::io::Emit16(Out, KeyLen); // 2 bytes for num of decls and 4 for each DeclID. unsigned DataLen = 2 + 4 * Lookup.size(); clang::io::Emit16(Out, DataLen); return std::make_pair(KeyLen, DataLen); } void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) { using namespace clang::io; Emit8(Out, Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo())); return; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector())); return; case DeclarationName::CXXOperatorName: assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS && "Invalid operator?"); Emit8(Out, Name.getCXXOverloadedOperator()); return; case DeclarationName::CXXLiteralOperatorName: Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); return; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: case DeclarationName::CXXUsingDirective: return; } llvm_unreachable("Invalid name kind?"); } void EmitData(raw_ostream& Out, key_type_ref, data_type Lookup, unsigned DataLen) { uint64_t Start = Out.tell(); (void)Start; clang::io::Emit16(Out, Lookup.size()); for (DeclContext::lookup_iterator I = Lookup.begin(), E = Lookup.end(); I != E; ++I) clang::io::Emit32(Out, Writer.GetDeclRef(*I)); assert(Out.tell() - Start == DataLen && "Data length is wrong"); } }; } // end anonymous namespace /// \brief Write the block containing all of the declaration IDs /// visible from the given DeclContext. /// /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the /// bitstream, or 0 if no block was written. uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC) { if (DC->getPrimaryContext() != DC) return 0; // Since there is no name lookup into functions or methods, don't bother to // build a visible-declarations table for these entities. if (DC->isFunctionOrMethod()) return 0; // If not in C++, we perform name lookup for the translation unit via the // IdentifierInfo chains, don't bother to build a visible-declarations table. if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus) return 0; // Serialize the contents of the mapping used for lookup. Note that, // although we have two very different code paths, the serialized // representation is the same for both cases: a declaration name, // followed by a size, followed by references to the visible // declarations that have that name. uint64_t Offset = Stream.GetCurrentBitNo(); StoredDeclsMap *Map = DC->buildLookup(); if (!Map || Map->empty()) return 0; OnDiskChainedHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // Create the on-disk hash table representation. DeclarationName ConversionName; SmallVector ConversionDecls; for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); D != DEnd; ++D) { DeclarationName Name = D->first; DeclContext::lookup_result Result = D->second.getLookupResult(); if (!Result.empty()) { if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { // Hash all conversion function names to the same name. The actual // type information in conversion function name is not used in the // key (since such type information is not stable across different // modules), so the intended effect is to coalesce all of the conversion // functions under a single key. if (!ConversionName) ConversionName = Name; ConversionDecls.append(Result.begin(), Result.end()); continue; } Generator.insert(Name, Result, Trait); } } // Add the conversion functions if (!ConversionDecls.empty()) { Generator.insert(ConversionName, DeclContext::lookup_result(ConversionDecls.begin(), ConversionDecls.end()), Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> LookupTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(LookupTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Write the lookup table RecordData Record; Record.push_back(DECL_CONTEXT_VISIBLE); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, LookupTable.str()); Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record); ++NumVisibleDeclContexts; return Offset; } /// \brief Write an UPDATE_VISIBLE block for the given context. /// /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing /// DeclContext in a dependent AST file. As such, they only exist for the TU /// (in C++), for namespaces, and for classes with forward-declared unscoped /// enumeration members (in C++11). void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { StoredDeclsMap *Map = static_cast(DC->getLookupPtr()); if (!Map || Map->empty()) return; OnDiskChainedHashTableGenerator Generator; ASTDeclContextNameLookupTrait Trait(*this); // Create the hash table. for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); D != DEnd; ++D) { DeclarationName Name = D->first; DeclContext::lookup_result Result = D->second.getLookupResult(); // For any name that appears in this table, the results are complete, i.e. // they overwrite results from previous PCHs. Merging is always a mess. if (!Result.empty()) Generator.insert(Name, Result, Trait); } // Create the on-disk hash table in a buffer. SmallString<4096> LookupTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(LookupTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); BucketOffset = Generator.Emit(Out, Trait); } // Write the lookup table RecordData Record; Record.push_back(UPDATE_VISIBLE); Record.push_back(getDeclID(cast(DC))); Record.push_back(BucketOffset); Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str()); } /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { RecordData Record; Record.push_back(Opts.fp_contract); Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); } /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { if (!SemaRef.Context.getLangOpts().OpenCL) return; const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); RecordData Record; #define OPENCLEXT(nm) Record.push_back(Opts.nm); #include "clang/Basic/OpenCLExtensions.def" Stream.EmitRecord(OPENCL_EXTENSIONS, Record); } void ASTWriter::WriteRedeclarations() { RecordData LocalRedeclChains; SmallVector LocalRedeclsMap; for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) { Decl *First = Redeclarations[I]; assert(First->isFirstDecl() && "Not the first declaration?"); Decl *MostRecent = First->getMostRecentDecl(); // If we only have a single declaration, there is no point in storing // a redeclaration chain. if (First == MostRecent) continue; unsigned Offset = LocalRedeclChains.size(); unsigned Size = 0; LocalRedeclChains.push_back(0); // Placeholder for the size. // Collect the set of local redeclarations of this declaration. for (Decl *Prev = MostRecent; Prev != First; Prev = Prev->getPreviousDecl()) { if (!Prev->isFromASTFile()) { AddDeclRef(Prev, LocalRedeclChains); ++Size; } } if (!First->isFromASTFile() && Chain) { Decl *FirstFromAST = MostRecent; for (Decl *Prev = MostRecent; Prev; Prev = Prev->getPreviousDecl()) { if (Prev->isFromASTFile()) FirstFromAST = Prev; } Chain->MergedDecls[FirstFromAST].push_back(getDeclID(First)); } LocalRedeclChains[Offset] = Size; // Reverse the set of local redeclarations, so that we store them in // order (since we found them in reverse order). std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end()); // Add the mapping from the first ID from the AST to the set of local // declarations. LocalRedeclarationsInfo Info = { getDeclID(First), Offset }; LocalRedeclsMap.push_back(Info); assert(N == Redeclarations.size() && "Deserialized a declaration we shouldn't have"); } if (LocalRedeclChains.empty()) return; // Sort the local redeclarations map by the first declaration ID, // since the reader will be performing binary searches on this information. llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end()); // Emit the local redeclarations map. using namespace llvm; llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(LOCAL_REDECLARATIONS_MAP); Record.push_back(LocalRedeclsMap.size()); Stream.EmitRecordWithBlob(AbbrevID, Record, reinterpret_cast(LocalRedeclsMap.data()), LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo)); // Emit the redeclaration chains. Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains); } void ASTWriter::WriteObjCCategories() { SmallVector CategoriesMap; RecordData Categories; for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) { unsigned Size = 0; unsigned StartIndex = Categories.size(); ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I]; // Allocate space for the size. Categories.push_back(0); // Add the categories. for (ObjCInterfaceDecl::known_categories_iterator Cat = Class->known_categories_begin(), CatEnd = Class->known_categories_end(); Cat != CatEnd; ++Cat, ++Size) { assert(getDeclID(*Cat) != 0 && "Bogus category"); AddDeclRef(*Cat, Categories); } // Update the size. Categories[StartIndex] = Size; // Record this interface -> category map. ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex }; CategoriesMap.push_back(CatInfo); } // Sort the categories map by the definition ID, since the reader will be // performing binary searches on this information. llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end()); // Emit the categories map. using namespace llvm; llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(OBJC_CATEGORIES_MAP); Record.push_back(CategoriesMap.size()); Stream.EmitRecordWithBlob(AbbrevID, Record, reinterpret_cast(CategoriesMap.data()), CategoriesMap.size() * sizeof(ObjCCategoriesInfo)); // Emit the category lists. Stream.EmitRecord(OBJC_CATEGORIES, Categories); } void ASTWriter::WriteMergedDecls() { if (!Chain || Chain->MergedDecls.empty()) return; RecordData Record; for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(), IEnd = Chain->MergedDecls.end(); I != IEnd; ++I) { DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID() : getDeclID(I->first); assert(CanonID && "Merged declaration not known?"); Record.push_back(CanonID); Record.push_back(I->second.size()); Record.append(I->second.begin(), I->second.end()); } Stream.EmitRecord(MERGED_DECLARATIONS, Record); } void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) { Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap; if (LPTMap.empty()) return; RecordData Record; for (Sema::LateParsedTemplateMapT::iterator It = LPTMap.begin(), ItEnd = LPTMap.end(); It != ItEnd; ++It) { LateParsedTemplate *LPT = It->second; AddDeclRef(It->first, Record); AddDeclRef(LPT->D, Record); Record.push_back(LPT->Toks.size()); for (CachedTokens::iterator TokIt = LPT->Toks.begin(), TokEnd = LPT->Toks.end(); TokIt != TokEnd; ++TokIt) { AddToken(*TokIt, Record); } } Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record); } //===----------------------------------------------------------------------===// // General Serialization Routines //===----------------------------------------------------------------------===// /// \brief Write a record containing the given attributes. void ASTWriter::WriteAttributes(ArrayRef Attrs, RecordDataImpl &Record) { Record.push_back(Attrs.size()); for (ArrayRef::iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){ const Attr *A = *i; Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs AddSourceRange(A->getRange(), Record); #include "clang/Serialization/AttrPCHWrite.inc" } } void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) { AddSourceLocation(Tok.getLocation(), Record); Record.push_back(Tok.getLength()); // FIXME: When reading literal tokens, reconstruct the literal pointer // if it is needed. AddIdentifierRef(Tok.getIdentifierInfo(), Record); // FIXME: Should translate token kind to a stable encoding. Record.push_back(Tok.getKind()); // FIXME: Should translate token flags to a stable encoding. Record.push_back(Tok.getFlags()); } void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { Record.push_back(Str.size()); Record.insert(Record.end(), Str.begin(), Str.end()); } void ASTWriter::AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record) { Record.push_back(Version.getMajor()); if (Optional Minor = Version.getMinor()) Record.push_back(*Minor + 1); else Record.push_back(0); if (Optional Subminor = Version.getSubminor()) Record.push_back(*Subminor + 1); else Record.push_back(0); } /// \brief Note that the identifier II occurs at the given offset /// within the identifier table. void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { IdentID ID = IdentifierIDs[II]; // Only store offsets new to this AST file. Other identifier names are looked // up earlier in the chain and thus don't need an offset. if (ID >= FirstIdentID) IdentifierOffsets[ID - FirstIdentID] = Offset; } /// \brief Note that the selector Sel occurs at the given offset /// within the method pool/selector table. void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { unsigned ID = SelectorIDs[Sel]; assert(ID && "Unknown selector"); // Don't record offsets for selectors that are also available in a different // file. if (ID < FirstSelectorID) return; SelectorOffsets[ID - FirstSelectorID] = Offset; } ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) : Stream(Stream), Context(0), PP(0), Chain(0), WritingModule(0), WritingAST(false), DoneWritingDeclsAndTypes(false), ASTHasCompilerErrors(false), FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID), FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), NextSubmoduleID(FirstSubmoduleID), FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), NumVisibleDeclContexts(0), NextCXXBaseSpecifiersID(1), DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0), DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0), DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0), DeclRecordAbbrev(0), IntegerLiteralAbbrev(0), DeclTypedefAbbrev(0), DeclVarAbbrev(0), DeclFieldAbbrev(0), DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0) { } ASTWriter::~ASTWriter() { llvm::DeleteContainerSeconds(FileDeclIDs); } void ASTWriter::WriteAST(Sema &SemaRef, const std::string &OutputFile, Module *WritingModule, StringRef isysroot, bool hasErrors) { WritingAST = true; ASTHasCompilerErrors = hasErrors; // Emit the file header. Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'P', 8); Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'H', 8); WriteBlockInfoBlock(); Context = &SemaRef.Context; PP = &SemaRef.PP; this->WritingModule = WritingModule; WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule); Context = 0; PP = 0; this->WritingModule = 0; WritingAST = false; } template static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, ASTWriter::RecordData &Record) { for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end(); I != E; ++I) { Writer.AddDeclRef(*I, Record); } } void ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, const std::string &OutputFile, Module *WritingModule) { using namespace llvm; bool isModule = WritingModule != 0; // Make sure that the AST reader knows to finalize itself. if (Chain) Chain->finalizeForWriting(); ASTContext &Context = SemaRef.Context; Preprocessor &PP = SemaRef.PP; // Set up predefined declaration IDs. DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID; if (Context.ObjCIdDecl) DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID; if (Context.ObjCSelDecl) DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID; if (Context.ObjCClassDecl) DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID; if (Context.ObjCProtocolClassDecl) DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID; if (Context.Int128Decl) DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID; if (Context.UInt128Decl) DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID; if (Context.ObjCInstanceTypeDecl) DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID; if (Context.BuiltinVaListDecl) DeclIDs[Context.getBuiltinVaListDecl()] = PREDEF_DECL_BUILTIN_VA_LIST_ID; if (!Chain) { // Make sure that we emit IdentifierInfos (and any attached // declarations) for builtins. We don't need to do this when we're // emitting chained PCH files, because all of the builtins will be // in the original PCH file. // FIXME: Modules won't like this at all. IdentifierTable &Table = PP.getIdentifierTable(); SmallVector BuiltinNames; if (!Context.getLangOpts().NoBuiltin) { Context.BuiltinInfo.GetBuiltinNames(BuiltinNames); } for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) getIdentifierRef(&Table.get(BuiltinNames[I])); } // If there are any out-of-date identifiers, bring them up to date. if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) { // Find out-of-date identifiers. SmallVector OutOfDate; for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) { if (ID->second->isOutOfDate()) OutOfDate.push_back(ID->second); } // Update the out-of-date identifiers. for (unsigned I = 0, N = OutOfDate.size(); I != N; ++I) { ExtSource->updateOutOfDateIdentifier(*OutOfDate[I]); } } // Build a record containing all of the tentative definitions in this file, in // TentativeDefinitions order. Generally, this record will be empty for // headers. RecordData TentativeDefinitions; AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions); // Build a record containing all of the file scoped decls in this file. RecordData UnusedFileScopedDecls; if (!isModule) AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls, UnusedFileScopedDecls); // Build a record containing all of the delegating constructors we still need // to resolve. RecordData DelegatingCtorDecls; if (!isModule) AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls); // Write the set of weak, undeclared identifiers. We always write the // entire table, since later PCH files in a PCH chain are only interested in // the results at the end of the chain. RecordData WeakUndeclaredIdentifiers; if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { for (llvm::DenseMap::iterator I = SemaRef.WeakUndeclaredIdentifiers.begin(), E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); } } // Build a record containing all of the locally-scoped extern "C" // declarations in this header file. Generally, this record will be // empty. RecordData LocallyScopedExternCDecls; // FIXME: This is filling in the AST file in densemap order which is // nondeterminstic! for (llvm::DenseMap::iterator TD = SemaRef.LocallyScopedExternCDecls.begin(), TDEnd = SemaRef.LocallyScopedExternCDecls.end(); TD != TDEnd; ++TD) { if (!TD->second->isFromASTFile()) AddDeclRef(TD->second, LocallyScopedExternCDecls); } // Build a record containing all of the ext_vector declarations. RecordData ExtVectorDecls; AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls); // Build a record containing all of the VTable uses information. RecordData VTableUses; if (!SemaRef.VTableUses.empty()) { for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); } } // Build a record containing all of dynamic classes declarations. RecordData DynamicClasses; AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses); // Build a record containing all of pending implicit instantiations. RecordData PendingInstantiations; for (std::deque::iterator I = SemaRef.PendingInstantiations.begin(), N = SemaRef.PendingInstantiations.end(); I != N; ++I) { AddDeclRef(I->first, PendingInstantiations); AddSourceLocation(I->second, PendingInstantiations); } assert(SemaRef.PendingLocalImplicitInstantiations.empty() && "There are local ones at end of translation unit!"); // Build a record containing some declaration references. RecordData SemaDeclRefs; if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); } RecordData CUDASpecialDeclRefs; if (Context.getcudaConfigureCallDecl()) { AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); } // Build a record containing all of the known namespaces. RecordData KnownNamespaces; for (llvm::MapVector::iterator I = SemaRef.KnownNamespaces.begin(), IEnd = SemaRef.KnownNamespaces.end(); I != IEnd; ++I) { if (!I->second) AddDeclRef(I->first, KnownNamespaces); } // Build a record of all used, undefined objects that require definitions. RecordData UndefinedButUsed; SmallVector, 16> Undefined; SemaRef.getUndefinedButUsed(Undefined); for (SmallVectorImpl >::iterator I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { AddDeclRef(I->first, UndefinedButUsed); AddSourceLocation(I->second, UndefinedButUsed); } // Write the control block WriteControlBlock(PP, Context, isysroot, OutputFile); // Write the remaining AST contents. RecordData Record; Stream.EnterSubblock(AST_BLOCK_ID, 5); // This is so that older clang versions, before the introduction // of the control block, can read and reject the newer PCH format. Record.clear(); Record.push_back(VERSION_MAJOR); Stream.EmitRecord(METADATA_OLD_FORMAT, Record); // Create a lexical update block containing all of the declarations in the // translation unit that do not come from other AST files. const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); SmallVector NewGlobalDecls; for (DeclContext::decl_iterator I = TU->noload_decls_begin(), E = TU->noload_decls_end(); I != E; ++I) { if (!(*I)->isFromASTFile()) NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I))); } llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); Record.clear(); Record.push_back(TU_UPDATE_LEXICAL); Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, data(NewGlobalDecls)); // And a visible updates block for the translation unit. Abv = new llvm::BitCodeAbbrev(); Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32)); Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv); WriteDeclContextVisibleUpdate(TU); // If the translation unit has an anonymous namespace, and we don't already // have an update block for it, write it as an update block. if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; if (Record.empty()) { Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE); Record.push_back(reinterpret_cast(NS)); } } // Make sure visible decls, added to DeclContexts previously loaded from // an AST file, are registered for serialization. for (SmallVectorImpl::iterator I = UpdatingVisibleDecls.begin(), E = UpdatingVisibleDecls.end(); I != E; ++I) { GetDeclRef(*I); } // Make sure all decls associated with an identifier are registered for // serialization. for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), IDEnd = PP.getIdentifierTable().end(); ID != IDEnd; ++ID) { const IdentifierInfo *II = ID->second; if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) { for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), DEnd = SemaRef.IdResolver.end(); D != DEnd; ++D) { GetDeclRef(*D); } } } // Resolve any declaration pointers within the declaration updates block. ResolveDeclUpdatesBlocks(); // Form the record of special types. RecordData SpecialTypes; AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); AddTypeRef(Context.getFILEType(), SpecialTypes); AddTypeRef(Context.getjmp_bufType(), SpecialTypes); AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes); AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes); AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); AddTypeRef(Context.getucontext_tType(), SpecialTypes); // Keep writing types and declarations until all types and // declarations have been written. Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); WriteDeclsBlockAbbrevs(); for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(), E = DeclsToRewrite.end(); I != E; ++I) DeclTypesToEmit.push(const_cast(*I)); while (!DeclTypesToEmit.empty()) { DeclOrType DOT = DeclTypesToEmit.front(); DeclTypesToEmit.pop(); if (DOT.isType()) WriteType(DOT.getType()); else WriteDecl(Context, DOT.getDecl()); } Stream.ExitBlock(); DoneWritingDeclsAndTypes = true; WriteFileDeclIDsMap(); WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); WriteComments(); if (Chain) { // Write the mapping information describing our module dependencies and how // each of those modules were mapped into our own offset/ID space, so that // the reader can build the appropriate mapping to its own offset/ID space. // The map consists solely of a blob with the following format: // *(module-name-len:i16 module-name:len*i8 // source-location-offset:i32 // identifier-id:i32 // preprocessed-entity-id:i32 // macro-definition-id:i32 // submodule-id:i32 // selector-id:i32 // declaration-id:i32 // c++-base-specifiers-id:i32 // type-id:i32) // llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); SmallString<2048> Buffer; { llvm::raw_svector_ostream Out(Buffer); for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), MEnd = Chain->ModuleMgr.end(); M != MEnd; ++M) { StringRef FileName = (*M)->FileName; io::Emit16(Out, FileName.size()); Out.write(FileName.data(), FileName.size()); io::Emit32(Out, (*M)->SLocEntryBaseOffset); io::Emit32(Out, (*M)->BaseIdentifierID); io::Emit32(Out, (*M)->BaseMacroID); io::Emit32(Out, (*M)->BasePreprocessedEntityID); io::Emit32(Out, (*M)->BaseSubmoduleID); io::Emit32(Out, (*M)->BaseSelectorID); io::Emit32(Out, (*M)->BaseDeclID); io::Emit32(Out, (*M)->BaseTypeIndex); } } Record.clear(); Record.push_back(MODULE_OFFSET_MAP); Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, Buffer.data(), Buffer.size()); } WritePreprocessor(PP, isModule); WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot); WriteSelectors(SemaRef); WriteReferencedSelectorsPool(SemaRef); WriteIdentifierTable(PP, SemaRef.IdResolver, isModule); WriteFPPragmaOptions(SemaRef.getFPOptions()); WriteOpenCLExtensions(SemaRef); WriteTypeDeclOffsets(); WritePragmaDiagnosticMappings(Context.getDiagnostics(), isModule); WriteCXXBaseSpecifiersOffsets(); // If we're emitting a module, write out the submodule information. if (WritingModule) WriteSubmodules(WritingModule); Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); // Write the record containing external, unnamed definitions. if (!EagerlyDeserializedDecls.empty()) Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls); // Write the record containing tentative definitions. if (!TentativeDefinitions.empty()) Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); // Write the record containing unused file scoped decls. if (!UnusedFileScopedDecls.empty()) Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); // Write the record containing weak undeclared identifiers. if (!WeakUndeclaredIdentifiers.empty()) Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, WeakUndeclaredIdentifiers); // Write the record containing locally-scoped extern "C" definitions. if (!LocallyScopedExternCDecls.empty()) Stream.EmitRecord(LOCALLY_SCOPED_EXTERN_C_DECLS, LocallyScopedExternCDecls); // Write the record containing ext_vector type names. if (!ExtVectorDecls.empty()) Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); // Write the record containing VTable uses information. if (!VTableUses.empty()) Stream.EmitRecord(VTABLE_USES, VTableUses); // Write the record containing dynamic classes declarations. if (!DynamicClasses.empty()) Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); // Write the record containing pending implicit instantiations. if (!PendingInstantiations.empty()) Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); // Write the record containing declaration references of Sema. if (!SemaDeclRefs.empty()) Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); // Write the record containing CUDA-specific declaration references. if (!CUDASpecialDeclRefs.empty()) Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); // Write the delegating constructors. if (!DelegatingCtorDecls.empty()) Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls); // Write the known namespaces. if (!KnownNamespaces.empty()) Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces); // Write the undefined internal functions and variables, and inline functions. if (!UndefinedButUsed.empty()) Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed); // Write the visible updates to DeclContexts. for (llvm::SmallPtrSet::iterator I = UpdatedDeclContexts.begin(), E = UpdatedDeclContexts.end(); I != E; ++I) WriteDeclContextVisibleUpdate(*I); if (!WritingModule) { // Write the submodules that were imported, if any. RecordData ImportedModules; for (ASTContext::import_iterator I = Context.local_import_begin(), IEnd = Context.local_import_end(); I != IEnd; ++I) { assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); ImportedModules.push_back(SubmoduleIDs[I->getImportedModule()]); } if (!ImportedModules.empty()) { // Sort module IDs. llvm::array_pod_sort(ImportedModules.begin(), ImportedModules.end()); // Unique module IDs. ImportedModules.erase(std::unique(ImportedModules.begin(), ImportedModules.end()), ImportedModules.end()); Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); } } WriteDeclUpdatesBlocks(); WriteDeclReplacementsBlock(); WriteRedeclarations(); WriteMergedDecls(); WriteObjCCategories(); WriteLateParsedTemplates(SemaRef); // Some simple statistics Record.clear(); Record.push_back(NumStatements); Record.push_back(NumMacros); Record.push_back(NumLexicalDeclContexts); Record.push_back(NumVisibleDeclContexts); Stream.EmitRecord(STATISTICS, Record); Stream.ExitBlock(); } /// \brief Go through the declaration update blocks and resolve declaration /// pointers into declaration IDs. void ASTWriter::ResolveDeclUpdatesBlocks() { for (DeclUpdateMap::iterator I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { const Decl *D = I->first; UpdateRecord &URec = I->second; if (isRewritten(D)) continue; // The decl will be written completely unsigned Idx = 0, N = URec.size(); while (Idx < N) { switch ((DeclUpdateKind)URec[Idx++]) { case UPD_CXX_ADDED_IMPLICIT_MEMBER: case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: URec[Idx] = GetDeclRef(reinterpret_cast(URec[Idx])); ++Idx; break; case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: case UPD_DECL_MARKED_USED: ++Idx; break; case UPD_CXX_DEDUCED_RETURN_TYPE: URec[Idx] = GetOrCreateTypeID( QualType::getFromOpaquePtr(reinterpret_cast(URec[Idx]))); ++Idx; break; } } } } void ASTWriter::WriteDeclUpdatesBlocks() { if (DeclUpdates.empty()) return; RecordData OffsetsRecord; Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); for (DeclUpdateMap::iterator I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { const Decl *D = I->first; UpdateRecord &URec = I->second; if (isRewritten(D)) continue; // The decl will be written completely,no need to store updates. uint64_t Offset = Stream.GetCurrentBitNo(); Stream.EmitRecord(DECL_UPDATES, URec); OffsetsRecord.push_back(GetDeclRef(D)); OffsetsRecord.push_back(Offset); } Stream.ExitBlock(); Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord); } void ASTWriter::WriteDeclReplacementsBlock() { if (ReplacedDecls.empty()) return; RecordData Record; for (SmallVectorImpl::iterator I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { Record.push_back(I->ID); Record.push_back(I->Offset); Record.push_back(I->Loc); } Stream.EmitRecord(DECL_REPLACEMENTS, Record); } void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { Record.push_back(Loc.getRawEncoding()); } void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { AddSourceLocation(Range.getBegin(), Record); AddSourceLocation(Range.getEnd(), Record); } void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) { Record.push_back(Value.getBitWidth()); const uint64_t *Words = Value.getRawData(); Record.append(Words, Words + Value.getNumWords()); } void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) { Record.push_back(Value.isUnsigned()); AddAPInt(Value, Record); } void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) { AddAPInt(Value.bitcastToAPInt(), Record); } void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { Record.push_back(getIdentifierRef(II)); } IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { if (II == 0) return 0; IdentID &ID = IdentifierIDs[II]; if (ID == 0) ID = NextIdentID++; return ID; } MacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) { // Don't emit builtin macros like __LINE__ to the AST file unless they // have been redefined by the header (in which case they are not // isBuiltinMacro). if (MI == 0 || MI->isBuiltinMacro()) return 0; MacroID &ID = MacroIDs[MI]; if (ID == 0) { ID = NextMacroID++; MacroInfoToEmitData Info = { Name, MI, ID }; MacroInfosToEmit.push_back(Info); } return ID; } MacroID ASTWriter::getMacroID(MacroInfo *MI) { if (MI == 0 || MI->isBuiltinMacro()) return 0; assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!"); return MacroIDs[MI]; } uint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) { assert(IdentMacroDirectivesOffsetMap[Name] && "not set!"); return IdentMacroDirectivesOffsetMap[Name]; } void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) { Record.push_back(getSelectorRef(SelRef)); } SelectorID ASTWriter::getSelectorRef(Selector Sel) { if (Sel.getAsOpaquePtr() == 0) { return 0; } SelectorID SID = SelectorIDs[Sel]; if (SID == 0 && Chain) { // This might trigger a ReadSelector callback, which will set the ID for // this selector. Chain->LoadSelector(Sel); SID = SelectorIDs[Sel]; } if (SID == 0) { SID = NextSelectorID++; SelectorIDs[Sel] = SID; } return SID; } void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) { AddDeclRef(Temp->getDestructor(), Record); } void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases, CXXBaseSpecifier const *BasesEnd, RecordDataImpl &Record) { assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded"); CXXBaseSpecifiersToWrite.push_back( QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID, Bases, BasesEnd)); Record.push_back(NextCXXBaseSpecifiersID++); } void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg, RecordDataImpl &Record) { switch (Kind) { case TemplateArgument::Expression: AddStmt(Arg.getAsExpr()); break; case TemplateArgument::Type: AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record); break; case TemplateArgument::Template: AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); AddSourceLocation(Arg.getTemplateNameLoc(), Record); break; case TemplateArgument::TemplateExpansion: AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); AddSourceLocation(Arg.getTemplateNameLoc(), Record); AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record); break; case TemplateArgument::Null: case TemplateArgument::Integral: case TemplateArgument::Declaration: case TemplateArgument::NullPtr: case TemplateArgument::Pack: // FIXME: Is this right? break; } } void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, RecordDataImpl &Record) { AddTemplateArgument(Arg.getArgument(), Record); if (Arg.getArgument().getKind() == TemplateArgument::Expression) { bool InfoHasSameExpr = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); Record.push_back(InfoHasSameExpr); if (InfoHasSameExpr) return; // Avoid storing the same expr twice. } AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(), Record); } void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordDataImpl &Record) { if (TInfo == 0) { AddTypeRef(QualType(), Record); return; } AddTypeLoc(TInfo->getTypeLoc(), Record); } void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) { AddTypeRef(TL.getType(), Record); TypeLocWriter TLW(*this, Record); for (; !TL.isNull(); TL = TL.getNextTypeLoc()) TLW.Visit(TL); } void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { Record.push_back(GetOrCreateTypeID(T)); } TypeID ASTWriter::GetOrCreateTypeID( QualType T) { assert(Context); return MakeTypeID(*Context, T, std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this)); } TypeID ASTWriter::getTypeID(QualType T) const { assert(Context); return MakeTypeID(*Context, T, std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this)); } TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); TypeIdx &Idx = TypeIdxs[T]; if (Idx.getIndex() == 0) { if (DoneWritingDeclsAndTypes) { assert(0 && "New type seen after serializing all the types to emit!"); return TypeIdx(); } // We haven't seen this type before. Assign it a new ID and put it // into the queue of types to emit. Idx = TypeIdx(NextTypeID++); DeclTypesToEmit.push(T); } return Idx; } TypeIdx ASTWriter::getTypeIdx(QualType T) const { if (T.isNull()) return TypeIdx(); assert(!T.getLocalFastQualifiers()); TypeIdxMap::const_iterator I = TypeIdxs.find(T); assert(I != TypeIdxs.end() && "Type not emitted!"); return I->second; } void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { Record.push_back(GetDeclRef(D)); } DeclID ASTWriter::GetDeclRef(const Decl *D) { assert(WritingAST && "Cannot request a declaration ID before AST writing"); if (D == 0) { return 0; } // If D comes from an AST file, its declaration ID is already known and // fixed. if (D->isFromASTFile()) return D->getGlobalID(); assert(!(reinterpret_cast(D) & 0x01) && "Invalid decl pointer"); DeclID &ID = DeclIDs[D]; if (ID == 0) { if (DoneWritingDeclsAndTypes) { assert(0 && "New decl seen after serializing all the decls to emit!"); return 0; } // We haven't seen this declaration before. Give it a new ID and // enqueue it in the list of declarations to emit. ID = NextDeclID++; DeclTypesToEmit.push(const_cast(D)); } return ID; } DeclID ASTWriter::getDeclID(const Decl *D) { if (D == 0) return 0; // If D comes from an AST file, its declaration ID is already known and // fixed. if (D->isFromASTFile()) return D->getGlobalID(); assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); return DeclIDs[D]; } void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { assert(ID); assert(D); SourceLocation Loc = D->getLocation(); if (Loc.isInvalid()) return; // We only keep track of the file-level declarations of each file. if (!D->getLexicalDeclContext()->isFileContext()) return; // FIXME: ParmVarDecls that are part of a function type of a parameter of // a function/objc method, should not have TU as lexical context. if (isa(D)) return; SourceManager &SM = Context->getSourceManager(); SourceLocation FileLoc = SM.getFileLoc(Loc); assert(SM.isLocalSourceLocation(FileLoc)); FileID FID; unsigned Offset; llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); if (FID.isInvalid()) return; assert(SM.getSLocEntry(FID).isFile()); DeclIDInFileInfo *&Info = FileDeclIDs[FID]; if (!Info) Info = new DeclIDInFileInfo(); std::pair LocDecl(Offset, ID); LocDeclIDsTy &Decls = Info->DeclIDs; if (Decls.empty() || Decls.back().first <= Offset) { Decls.push_back(LocDecl); return; } LocDeclIDsTy::iterator I = std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first()); Decls.insert(I, LocDecl); } void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) { // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. Record.push_back(Name.getNameKind()); switch (Name.getNameKind()) { case DeclarationName::Identifier: AddIdentifierRef(Name.getAsIdentifierInfo(), Record); break; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: AddSelectorRef(Name.getObjCSelector(), Record); break; case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: AddTypeRef(Name.getCXXNameType(), Record); break; case DeclarationName::CXXOperatorName: Record.push_back(Name.getCXXOverloadedOperator()); break; case DeclarationName::CXXLiteralOperatorName: AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record); break; case DeclarationName::CXXUsingDirective: // No extra data to emit break; } } void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name, RecordDataImpl &Record) { switch (Name.getNameKind()) { case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record); break; case DeclarationName::CXXOperatorName: AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc), Record); AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc), Record); break; case DeclarationName::CXXLiteralOperatorName: AddSourceLocation( SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc), Record); break; case DeclarationName::Identifier: case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: case DeclarationName::CXXUsingDirective: break; } } void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo, RecordDataImpl &Record) { AddDeclarationName(NameInfo.getName(), Record); AddSourceLocation(NameInfo.getLoc(), Record); AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record); } void ASTWriter::AddQualifierInfo(const QualifierInfo &Info, RecordDataImpl &Record) { AddNestedNameSpecifierLoc(Info.QualifierLoc, Record); Record.push_back(Info.NumTemplParamLists); for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i) AddTemplateParameterList(Info.TemplParamLists[i], Record); } void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS, RecordDataImpl &Record) { // Nested name specifiers usually aren't too long. I think that 8 would // typically accommodate the vast majority. SmallVector NestedNames; // Push each of the NNS's onto a stack for serialization in reverse order. while (NNS) { NestedNames.push_back(NNS); NNS = NNS->getPrefix(); } Record.push_back(NestedNames.size()); while(!NestedNames.empty()) { NNS = NestedNames.pop_back_val(); NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); Record.push_back(Kind); switch (Kind) { case NestedNameSpecifier::Identifier: AddIdentifierRef(NNS->getAsIdentifier(), Record); break; case NestedNameSpecifier::Namespace: AddDeclRef(NNS->getAsNamespace(), Record); break; case NestedNameSpecifier::NamespaceAlias: AddDeclRef(NNS->getAsNamespaceAlias(), Record); break; case NestedNameSpecifier::TypeSpec: case NestedNameSpecifier::TypeSpecWithTemplate: AddTypeRef(QualType(NNS->getAsType(), 0), Record); Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); break; case NestedNameSpecifier::Global: // Don't need to write an associated value. break; } } } void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, RecordDataImpl &Record) { // Nested name specifiers usually aren't too long. I think that 8 would // typically accommodate the vast majority. SmallVector NestedNames; // Push each of the nested-name-specifiers's onto a stack for // serialization in reverse order. while (NNS) { NestedNames.push_back(NNS); NNS = NNS.getPrefix(); } Record.push_back(NestedNames.size()); while(!NestedNames.empty()) { NNS = NestedNames.pop_back_val(); NestedNameSpecifier::SpecifierKind Kind = NNS.getNestedNameSpecifier()->getKind(); Record.push_back(Kind); switch (Kind) { case NestedNameSpecifier::Identifier: AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::Namespace: AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::NamespaceAlias: AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record); AddSourceRange(NNS.getLocalSourceRange(), Record); break; case NestedNameSpecifier::TypeSpec: case NestedNameSpecifier::TypeSpecWithTemplate: Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); AddTypeLoc(NNS.getTypeLoc(), Record); AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); break; case NestedNameSpecifier::Global: AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); break; } } } void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) { TemplateName::NameKind Kind = Name.getKind(); Record.push_back(Kind); switch (Kind) { case TemplateName::Template: AddDeclRef(Name.getAsTemplateDecl(), Record); break; case TemplateName::OverloadedTemplate: { OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); Record.push_back(OvT->size()); for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end(); I != E; ++I) AddDeclRef(*I, Record); break; } case TemplateName::QualifiedTemplate: { QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); AddNestedNameSpecifier(QualT->getQualifier(), Record); Record.push_back(QualT->hasTemplateKeyword()); AddDeclRef(QualT->getTemplateDecl(), Record); break; } case TemplateName::DependentTemplate: { DependentTemplateName *DepT = Name.getAsDependentTemplateName(); AddNestedNameSpecifier(DepT->getQualifier(), Record); Record.push_back(DepT->isIdentifier()); if (DepT->isIdentifier()) AddIdentifierRef(DepT->getIdentifier(), Record); else Record.push_back(DepT->getOperator()); break; } case TemplateName::SubstTemplateTemplateParm: { SubstTemplateTemplateParmStorage *subst = Name.getAsSubstTemplateTemplateParm(); AddDeclRef(subst->getParameter(), Record); AddTemplateName(subst->getReplacement(), Record); break; } case TemplateName::SubstTemplateTemplateParmPack: { SubstTemplateTemplateParmPackStorage *SubstPack = Name.getAsSubstTemplateTemplateParmPack(); AddDeclRef(SubstPack->getParameterPack(), Record); AddTemplateArgument(SubstPack->getArgumentPack(), Record); break; } } } void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, RecordDataImpl &Record) { Record.push_back(Arg.getKind()); switch (Arg.getKind()) { case TemplateArgument::Null: break; case TemplateArgument::Type: AddTypeRef(Arg.getAsType(), Record); break; case TemplateArgument::Declaration: AddDeclRef(Arg.getAsDecl(), Record); Record.push_back(Arg.isDeclForReferenceParam()); break; case TemplateArgument::NullPtr: AddTypeRef(Arg.getNullPtrType(), Record); break; case TemplateArgument::Integral: AddAPSInt(Arg.getAsIntegral(), Record); AddTypeRef(Arg.getIntegralType(), Record); break; case TemplateArgument::Template: AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); break; case TemplateArgument::TemplateExpansion: AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); if (Optional NumExpansions = Arg.getNumTemplateExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); break; case TemplateArgument::Expression: AddStmt(Arg.getAsExpr()); break; case TemplateArgument::Pack: Record.push_back(Arg.pack_size()); for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); I != E; ++I) AddTemplateArgument(*I, Record); break; } } void ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams, RecordDataImpl &Record) { assert(TemplateParams && "No TemplateParams!"); AddSourceLocation(TemplateParams->getTemplateLoc(), Record); AddSourceLocation(TemplateParams->getLAngleLoc(), Record); AddSourceLocation(TemplateParams->getRAngleLoc(), Record); Record.push_back(TemplateParams->size()); for (TemplateParameterList::const_iterator P = TemplateParams->begin(), PEnd = TemplateParams->end(); P != PEnd; ++P) AddDeclRef(*P, Record); } /// \brief Emit a template argument list. void ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs, RecordDataImpl &Record) { assert(TemplateArgs && "No TemplateArgs!"); Record.push_back(TemplateArgs->size()); for (int i=0, e = TemplateArgs->size(); i != e; ++i) AddTemplateArgument(TemplateArgs->get(i), Record); } void ASTWriter::AddASTTemplateArgumentListInfo (const ASTTemplateArgumentListInfo *ASTTemplArgList, RecordDataImpl &Record) { assert(ASTTemplArgList && "No ASTTemplArgList!"); AddSourceLocation(ASTTemplArgList->LAngleLoc, Record); AddSourceLocation(ASTTemplArgList->RAngleLoc, Record); Record.push_back(ASTTemplArgList->NumTemplateArgs); const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs(); for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) AddTemplateArgumentLoc(TemplArgs[i], Record); } void ASTWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record) { Record.push_back(Set.size()); for (ASTUnresolvedSet::const_iterator I = Set.begin(), E = Set.end(); I != E; ++I) { AddDeclRef(I.getDecl(), Record); Record.push_back(I.getAccess()); } } void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, RecordDataImpl &Record) { Record.push_back(Base.isVirtual()); Record.push_back(Base.isBaseOfClass()); Record.push_back(Base.getAccessSpecifierAsWritten()); Record.push_back(Base.getInheritConstructors()); AddTypeSourceInfo(Base.getTypeSourceInfo(), Record); AddSourceRange(Base.getSourceRange(), Record); AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() : SourceLocation(), Record); } void ASTWriter::FlushCXXBaseSpecifiers() { RecordData Record; for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) { Record.clear(); // Record the offset of this base-specifier set. unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1; if (Index == CXXBaseSpecifiersOffsets.size()) CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo()); else { if (Index > CXXBaseSpecifiersOffsets.size()) CXXBaseSpecifiersOffsets.resize(Index + 1); CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo(); } const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases, *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd; Record.push_back(BEnd - B); for (; B != BEnd; ++B) AddCXXBaseSpecifier(*B, Record); Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record); // Flush any expressions that were written as part of the base specifiers. FlushStmts(); } CXXBaseSpecifiersToWrite.clear(); } void ASTWriter::AddCXXCtorInitializers( const CXXCtorInitializer * const *CtorInitializers, unsigned NumCtorInitializers, RecordDataImpl &Record) { Record.push_back(NumCtorInitializers); for (unsigned i=0; i != NumCtorInitializers; ++i) { const CXXCtorInitializer *Init = CtorInitializers[i]; if (Init->isBaseInitializer()) { Record.push_back(CTOR_INITIALIZER_BASE); AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); Record.push_back(Init->isBaseVirtual()); } else if (Init->isDelegatingInitializer()) { Record.push_back(CTOR_INITIALIZER_DELEGATING); AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); } else if (Init->isMemberInitializer()){ Record.push_back(CTOR_INITIALIZER_MEMBER); AddDeclRef(Init->getMember(), Record); } else { Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); AddDeclRef(Init->getIndirectMember(), Record); } AddSourceLocation(Init->getMemberLocation(), Record); AddStmt(Init->getInit()); AddSourceLocation(Init->getLParenLoc(), Record); AddSourceLocation(Init->getRParenLoc(), Record); Record.push_back(Init->isWritten()); if (Init->isWritten()) { Record.push_back(Init->getSourceOrder()); } else { Record.push_back(Init->getNumArrayIndices()); for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i) AddDeclRef(Init->getArrayIndex(i), Record); } } } void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) { assert(D->DefinitionData); struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData; Record.push_back(Data.IsLambda); Record.push_back(Data.UserDeclaredConstructor); Record.push_back(Data.UserDeclaredSpecialMembers); Record.push_back(Data.Aggregate); Record.push_back(Data.PlainOldData); Record.push_back(Data.Empty); Record.push_back(Data.Polymorphic); Record.push_back(Data.Abstract); Record.push_back(Data.IsStandardLayout); Record.push_back(Data.HasNoNonEmptyBases); Record.push_back(Data.HasPrivateFields); Record.push_back(Data.HasProtectedFields); Record.push_back(Data.HasPublicFields); Record.push_back(Data.HasMutableFields); Record.push_back(Data.HasVariantMembers); Record.push_back(Data.HasOnlyCMembers); Record.push_back(Data.HasInClassInitializer); Record.push_back(Data.HasUninitializedReferenceMember); Record.push_back(Data.NeedOverloadResolutionForMoveConstructor); Record.push_back(Data.NeedOverloadResolutionForMoveAssignment); Record.push_back(Data.NeedOverloadResolutionForDestructor); Record.push_back(Data.DefaultedMoveConstructorIsDeleted); Record.push_back(Data.DefaultedMoveAssignmentIsDeleted); Record.push_back(Data.DefaultedDestructorIsDeleted); Record.push_back(Data.HasTrivialSpecialMembers); Record.push_back(Data.HasIrrelevantDestructor); Record.push_back(Data.HasConstexprNonCopyMoveConstructor); Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr); Record.push_back(Data.HasConstexprDefaultConstructor); Record.push_back(Data.HasNonLiteralTypeFieldsOrBases); Record.push_back(Data.ComputedVisibleConversions); Record.push_back(Data.UserProvidedDefaultConstructor); Record.push_back(Data.DeclaredSpecialMembers); Record.push_back(Data.ImplicitCopyConstructorHasConstParam); Record.push_back(Data.ImplicitCopyAssignmentHasConstParam); Record.push_back(Data.HasDeclaredCopyConstructorWithConstParam); Record.push_back(Data.HasDeclaredCopyAssignmentWithConstParam); // IsLambda bit is already saved. Record.push_back(Data.NumBases); if (Data.NumBases > 0) AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases, Record); // FIXME: Make VBases lazily computed when needed to avoid storing them. Record.push_back(Data.NumVBases); if (Data.NumVBases > 0) AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases, Record); AddUnresolvedSet(Data.Conversions.get(*Context), Record); AddUnresolvedSet(Data.VisibleConversions.get(*Context), Record); // Data.Definition is the owning decl, no need to write it. AddDeclRef(D->getFirstFriend(), Record); // Add lambda-specific data. if (Data.IsLambda) { CXXRecordDecl::LambdaDefinitionData &Lambda = D->getLambdaData(); Record.push_back(Lambda.Dependent); Record.push_back(Lambda.IsGenericLambda); Record.push_back(Lambda.CaptureDefault); Record.push_back(Lambda.NumCaptures); Record.push_back(Lambda.NumExplicitCaptures); Record.push_back(Lambda.ManglingNumber); AddDeclRef(Lambda.ContextDecl, Record); AddTypeSourceInfo(Lambda.MethodTyInfo, Record); for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { LambdaExpr::Capture &Capture = Lambda.Captures[I]; AddSourceLocation(Capture.getLocation(), Record); Record.push_back(Capture.isImplicit()); Record.push_back(Capture.getCaptureKind()); switch (Capture.getCaptureKind()) { case LCK_This: break; case LCK_ByCopy: case LCK_ByRef: VarDecl *Var = Capture.capturesVariable() ? Capture.getCapturedVar() : 0; AddDeclRef(Var, Record); AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc() : SourceLocation(), Record); break; } } } } void ASTWriter::ReaderInitialized(ASTReader *Reader) { assert(Reader && "Cannot remove chain"); assert((!Chain || Chain == Reader) && "Cannot replace chain"); assert(FirstDeclID == NextDeclID && FirstTypeID == NextTypeID && FirstIdentID == NextIdentID && FirstMacroID == NextMacroID && FirstSubmoduleID == NextSubmoduleID && FirstSelectorID == NextSelectorID && "Setting chain after writing has started."); Chain = Reader; FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros(); FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); NextDeclID = FirstDeclID; NextTypeID = FirstTypeID; NextIdentID = FirstIdentID; NextMacroID = FirstMacroID; NextSelectorID = FirstSelectorID; NextSubmoduleID = FirstSubmoduleID; } void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { // Always keep the highest ID. See \p TypeRead() for more information. IdentID &StoredID = IdentifierIDs[II]; if (ID > StoredID) StoredID = ID; } void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) { // Always keep the highest ID. See \p TypeRead() for more information. MacroID &StoredID = MacroIDs[MI]; if (ID > StoredID) StoredID = ID; } void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { // Always take the highest-numbered type index. This copes with an interesting // case for chained AST writing where we schedule writing the type and then, // later, deserialize the type from another AST. In this case, we want to // keep the higher-numbered entry so that we can properly write it out to // the AST file. TypeIdx &StoredIdx = TypeIdxs[T]; if (Idx.getIndex() >= StoredIdx.getIndex()) StoredIdx = Idx; } void ASTWriter::SelectorRead(SelectorID ID, Selector S) { // Always keep the highest ID. See \p TypeRead() for more information. SelectorID &StoredID = SelectorIDs[S]; if (ID > StoredID) StoredID = ID; } void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, MacroDefinition *MD) { assert(MacroDefinitions.find(MD) == MacroDefinitions.end()); MacroDefinitions[MD] = ID; } void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); SubmoduleIDs[Mod] = ID; } void ASTWriter::CompletedTagDefinition(const TagDecl *D) { assert(D->isCompleteDefinition()); assert(!WritingAST && "Already writing the AST!"); if (const CXXRecordDecl *RD = dyn_cast(D)) { // We are interested when a PCH decl is modified. if (RD->isFromASTFile()) { // A forward reference was mutated into a definition. Rewrite it. // FIXME: This happens during template instantiation, should we // have created a new definition decl instead ? RewriteDecl(RD); } } } void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { assert(!WritingAST && "Already writing the AST!"); // TU and namespaces are handled elsewhere. if (isa(DC) || isa(DC)) return; if (!(!D->isFromASTFile() && cast(DC)->isFromASTFile())) return; // Not a source decl added to a DeclContext from PCH. assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!"); AddUpdatedDeclContext(DC); UpdatingVisibleDecls.push_back(D); } void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { assert(!WritingAST && "Already writing the AST!"); assert(D->isImplicit()); if (!(!D->isFromASTFile() && RD->isFromASTFile())) return; // Not a source member added to a class from PCH. if (!isa(D)) return; // We are interested in lazily declared implicit methods. // A decl coming from PCH was modified. assert(RD->isCompleteDefinition()); UpdateRecord &Record = DeclUpdates[RD]; Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER); Record.push_back(reinterpret_cast(D)); } void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. UpdateRecord &Record = DeclUpdates[TD]; Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); Record.push_back(reinterpret_cast(D)); } void ASTWriter::AddedCXXTemplateSpecialization( const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. UpdateRecord &Record = DeclUpdates[TD]; Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); Record.push_back(reinterpret_cast(D)); } void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, const FunctionDecl *D) { // The specializations set is kept in the canonical template. assert(!WritingAST && "Already writing the AST!"); TD = TD->getCanonicalDecl(); if (!(!D->isFromASTFile() && TD->isFromASTFile())) return; // Not a source specialization added to a template from PCH. UpdateRecord &Record = DeclUpdates[TD]; Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); Record.push_back(reinterpret_cast(D)); } void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { assert(!WritingAST && "Already writing the AST!"); FD = FD->getCanonicalDecl(); if (!FD->isFromASTFile()) return; // Not a function declared in PCH and defined outside. UpdateRecord &Record = DeclUpdates[FD]; Record.push_back(UPD_CXX_DEDUCED_RETURN_TYPE); Record.push_back(reinterpret_cast(ReturnType.getAsOpaquePtr())); } void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Declaration not imported from PCH. // Implicit decl from a PCH was defined. // FIXME: Should implicit definition be a separate FunctionDecl? RewriteDecl(D); } void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Since the actual instantiation is delayed, this really means that we need // to update the instantiation location. UpdateRecord &Record = DeclUpdates[D]; Record.push_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER); AddSourceLocation( D->getMemberSpecializationInfo()->getPointOfInstantiation(), Record); } void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, const ObjCInterfaceDecl *IFD) { assert(!WritingAST && "Already writing the AST!"); if (!IFD->isFromASTFile()) return; // Declaration not imported from PCH. assert(IFD->getDefinition() && "Category on a class without a definition?"); ObjCClassesWithCategories.insert( const_cast(IFD->getDefinition())); } void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, const ObjCPropertyDecl *OrigProp, const ObjCCategoryDecl *ClassExt) { const ObjCInterfaceDecl *D = ClassExt->getClassInterface(); if (!D) return; assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; // Declaration not imported from PCH. RewriteDecl(D); } void ASTWriter::DeclarationMarkedUsed(const Decl *D) { assert(!WritingAST && "Already writing the AST!"); if (!D->isFromASTFile()) return; UpdateRecord &Record = DeclUpdates[D]; Record.push_back(UPD_DECL_MARKED_USED); } @