diff --git a/clang/include/clang/AST/DeclBase.h b/clang/include/clang/AST/DeclBase.h index f784fa73af5ba..fdc59ac7419d9 100644 --- a/clang/include/clang/AST/DeclBase.h +++ b/clang/include/clang/AST/DeclBase.h @@ -211,7 +211,7 @@ class alignas(8) Decl { /// The kind of ownership a declaration has, for visibility purposes. /// This enumeration is designed such that higher values represent higher /// levels of name hiding. - enum class ModuleOwnershipKind : unsigned { + enum class ModuleOwnershipKind : unsigned char { /// This declaration is not owned by a module. Unowned, diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h index 531ad94f0906a..bafbe779d60ac 100644 --- a/clang/include/clang/Serialization/ASTReader.h +++ b/clang/include/clang/Serialization/ASTReader.h @@ -2407,6 +2407,53 @@ class ASTReader bool isProcessingUpdateRecords() { return ProcessingUpdateRecords; } }; +/// A simple helper class to unpack an integer to bits and consuming +/// the bits in order. +class BitsUnpacker { + constexpr static uint32_t BitsIndexUpbound = 32; + +public: + BitsUnpacker(uint32_t V) { updateValue(V); } + BitsUnpacker(const BitsUnpacker &) = delete; + BitsUnpacker(BitsUnpacker &&) = delete; + BitsUnpacker operator=(const BitsUnpacker &) = delete; + BitsUnpacker operator=(BitsUnpacker &&) = delete; + ~BitsUnpacker() { +#ifndef NDEBUG + while (isValid()) + assert(!getNextBit() && "There are unprocessed bits!"); +#endif + } + + void updateValue(uint32_t V) { + Value = V; + CurrentBitsIndex = 0; + } + + bool getNextBit() { + assert(isValid()); + return Value & (1 << CurrentBitsIndex++); + } + + uint32_t getNextBits(uint32_t Width) { + assert(isValid()); + assert(Width < BitsIndexUpbound); + uint32_t Ret = (Value >> CurrentBitsIndex) & ((1 << Width) - 1); + CurrentBitsIndex += Width; + return Ret; + } + + bool canGetNextNBits(uint32_t Width) const { + return CurrentBitsIndex + Width < BitsIndexUpbound; + } + +private: + bool isValid() const { return CurrentBitsIndex < BitsIndexUpbound; } + + uint32_t Value; + uint32_t CurrentBitsIndex = ~0; +}; + } // namespace clang #endif // LLVM_CLANG_SERIALIZATION_ASTREADER_H diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h index 98445d40ebd82..3019bbc2ddc9c 100644 --- a/clang/include/clang/Serialization/ASTWriter.h +++ b/clang/include/clang/Serialization/ASTWriter.h @@ -830,6 +830,59 @@ class PCHGenerator : public SemaConsumer { bool hasEmittedPCH() const { return Buffer->IsComplete; } }; +/// A simple helper class to pack several bits in order into (a) 32 bit +/// integer(s). +class BitsPacker { + constexpr static uint32_t BitIndexUpbound = 32u; + +public: + BitsPacker() = default; + BitsPacker(const BitsPacker &) = delete; + BitsPacker(BitsPacker &&) = delete; + BitsPacker operator=(const BitsPacker &) = delete; + BitsPacker operator=(BitsPacker &&) = delete; + ~BitsPacker() { + assert(!hasUnconsumedValues() && "There are unprocessed bits!"); + } + + void addBit(bool Value) { addBits(Value, 1); } + void addBits(uint32_t Value, uint32_t BitsWidth) { + assert(BitsWidth < BitIndexUpbound); + assert((Value < (1u << BitsWidth)) && "Passing narrower bit width!"); + + if (CurrentBitIndex + BitsWidth >= BitIndexUpbound) { + Values.push_back(0); + CurrentBitIndex = 0; + } + + assert(CurrentBitIndex < BitIndexUpbound); + Values.back() |= Value << CurrentBitIndex; + CurrentBitIndex += BitsWidth; + } + + bool hasUnconsumedValues() const { + return ConsumingValueIndex < Values.size(); + } + uint32_t getNextValue() { + assert(hasUnconsumedValues()); + return Values[ConsumingValueIndex++]; + } + + // We can convert the packer to an uint32_t if there is only one values. + operator uint32_t() { + assert(Values.size() == 1); + return getNextValue(); + } + +private: + SmallVector Values; + uint16_t ConsumingValueIndex = 0; + // Initialize CurrentBitIndex with an invalid value + // to make it easier to update Values. See the implementation + // of `addBits` to see the details. + uint16_t CurrentBitIndex = BitIndexUpbound; +}; + } // namespace clang #endif // LLVM_CLANG_SERIALIZATION_ASTWRITER_H diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp index 00f57f88781e6..a63911cb4adfb 100644 --- a/clang/lib/Serialization/ASTReaderDecl.cpp +++ b/clang/lib/Serialization/ASTReaderDecl.cpp @@ -617,24 +617,29 @@ void ASTDeclReader::VisitDecl(Decl *D) { Reader.getContext()); } D->setLocation(ThisDeclLoc); - D->InvalidDecl = Record.readInt(); - if (Record.readInt()) { // hasAttrs + + BitsUnpacker DeclBits(Record.readInt()); + D->InvalidDecl = DeclBits.getNextBit(); + bool HasAttrs = DeclBits.getNextBit(); + D->setImplicit(DeclBits.getNextBit()); + D->Used = DeclBits.getNextBit(); + IsDeclMarkedUsed |= D->Used; + D->setReferenced(DeclBits.getNextBit()); + D->setTopLevelDeclInObjCContainer(DeclBits.getNextBit()); + D->setAccess((AccessSpecifier)DeclBits.getNextBits(/*Width=*/2)); + D->FromASTFile = true; + auto ModuleOwnership = + (Decl::ModuleOwnershipKind)DeclBits.getNextBits(/*Width=*/3); + bool ModulePrivate = + (ModuleOwnership == Decl::ModuleOwnershipKind::ModulePrivate); + + if (HasAttrs) { AttrVec Attrs; Record.readAttributes(Attrs); // Avoid calling setAttrs() directly because it uses Decl::getASTContext() // internally which is unsafe during derialization. D->setAttrsImpl(Attrs, Reader.getContext()); } - D->setImplicit(Record.readInt()); - D->Used = Record.readInt(); - IsDeclMarkedUsed |= D->Used; - D->setReferenced(Record.readInt()); - D->setTopLevelDeclInObjCContainer(Record.readInt()); - D->setAccess((AccessSpecifier)Record.readInt()); - D->FromASTFile = true; - auto ModuleOwnership = (Decl::ModuleOwnershipKind)Record.readInt(); - bool ModulePrivate = - (ModuleOwnership == Decl::ModuleOwnershipKind::ModulePrivate); // Determine whether this declaration is part of a (sub)module. If so, it // may not yet be visible. @@ -750,12 +755,13 @@ ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) { VisitTypeDecl(TD); TD->IdentifierNamespace = Record.readInt(); - TD->setTagKind((TagDecl::TagKind)Record.readInt()); - if (!isa(TD)) - TD->setCompleteDefinition(Record.readInt()); - TD->setEmbeddedInDeclarator(Record.readInt()); - TD->setFreeStanding(Record.readInt()); - TD->setCompleteDefinitionRequired(Record.readInt()); + + BitsUnpacker TagDeclBits(Record.readInt()); + TD->setTagKind((TagDecl::TagKind)TagDeclBits.getNextBits(/*Width=*/3)); + TD->setCompleteDefinition(TagDeclBits.getNextBit()); + TD->setEmbeddedInDeclarator(TagDeclBits.getNextBit()); + TD->setFreeStanding(TagDeclBits.getNextBit()); + TD->setCompleteDefinitionRequired(TagDeclBits.getNextBit()); TD->setBraceRange(readSourceRange()); switch (Record.readInt()) { @@ -787,11 +793,13 @@ void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) { else ED->setIntegerType(Record.readType()); ED->setPromotionType(Record.readType()); - ED->setNumPositiveBits(Record.readInt()); - ED->setNumNegativeBits(Record.readInt()); - ED->setScoped(Record.readInt()); - ED->setScopedUsingClassTag(Record.readInt()); - ED->setFixed(Record.readInt()); + + BitsUnpacker EnumDeclBits(Record.readInt()); + ED->setNumPositiveBits(EnumDeclBits.getNextBits(/*Width=*/8)); + ED->setNumNegativeBits(EnumDeclBits.getNextBits(/*Width=*/8)); + ED->setScoped(EnumDeclBits.getNextBit()); + ED->setScopedUsingClassTag(EnumDeclBits.getNextBit()); + ED->setFixed(EnumDeclBits.getNextBit()); ED->setHasODRHash(true); ED->ODRHash = Record.readInt(); @@ -834,18 +842,22 @@ void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) { ASTDeclReader::RedeclarableResult ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) { RedeclarableResult Redecl = VisitTagDecl(RD); - RD->setHasFlexibleArrayMember(Record.readInt()); - RD->setAnonymousStructOrUnion(Record.readInt()); - RD->setHasObjectMember(Record.readInt()); - RD->setHasVolatileMember(Record.readInt()); - RD->setNonTrivialToPrimitiveDefaultInitialize(Record.readInt()); - RD->setNonTrivialToPrimitiveCopy(Record.readInt()); - RD->setNonTrivialToPrimitiveDestroy(Record.readInt()); - RD->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(Record.readInt()); - RD->setHasNonTrivialToPrimitiveDestructCUnion(Record.readInt()); - RD->setHasNonTrivialToPrimitiveCopyCUnion(Record.readInt()); - RD->setParamDestroyedInCallee(Record.readInt()); - RD->setArgPassingRestrictions((RecordArgPassingKind)Record.readInt()); + + BitsUnpacker RecordDeclBits(Record.readInt()); + RD->setHasFlexibleArrayMember(RecordDeclBits.getNextBit()); + RD->setAnonymousStructOrUnion(RecordDeclBits.getNextBit()); + RD->setHasObjectMember(RecordDeclBits.getNextBit()); + RD->setHasVolatileMember(RecordDeclBits.getNextBit()); + RD->setNonTrivialToPrimitiveDefaultInitialize(RecordDeclBits.getNextBit()); + RD->setNonTrivialToPrimitiveCopy(RecordDeclBits.getNextBit()); + RD->setNonTrivialToPrimitiveDestroy(RecordDeclBits.getNextBit()); + RD->setHasNonTrivialToPrimitiveDefaultInitializeCUnion( + RecordDeclBits.getNextBit()); + RD->setHasNonTrivialToPrimitiveDestructCUnion(RecordDeclBits.getNextBit()); + RD->setHasNonTrivialToPrimitiveCopyCUnion(RecordDeclBits.getNextBit()); + RD->setParamDestroyedInCallee(RecordDeclBits.getNextBit()); + RD->setArgPassingRestrictions( + (RecordArgPassingKind)RecordDeclBits.getNextBits(/*Width=*/2)); return Redecl; } @@ -1046,32 +1058,35 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) { // FunctionDecl's body is handled last at ASTDeclReader::Visit, // after everything else is read. + BitsUnpacker FunctionDeclBits(Record.readInt()); - FD->setStorageClass(static_cast(Record.readInt())); - FD->setInlineSpecified(Record.readInt()); - FD->setImplicitlyInline(Record.readInt()); - FD->setVirtualAsWritten(Record.readInt()); + FD->setStorageClass((StorageClass)FunctionDeclBits.getNextBits(/*Width=*/3)); + FD->setInlineSpecified(FunctionDeclBits.getNextBit()); + FD->setImplicitlyInline(FunctionDeclBits.getNextBit()); + FD->setVirtualAsWritten(FunctionDeclBits.getNextBit()); // We defer calling `FunctionDecl::setPure()` here as for methods of // `CXXTemplateSpecializationDecl`s, we may not have connected up the // definition (which is required for `setPure`). - const bool Pure = Record.readInt(); - FD->setHasInheritedPrototype(Record.readInt()); - FD->setHasWrittenPrototype(Record.readInt()); - FD->setDeletedAsWritten(Record.readInt()); - FD->setTrivial(Record.readInt()); - FD->setTrivialForCall(Record.readInt()); - FD->setDefaulted(Record.readInt()); - FD->setExplicitlyDefaulted(Record.readInt()); - FD->setIneligibleOrNotSelected(Record.readInt()); - FD->setHasImplicitReturnZero(Record.readInt()); - FD->setConstexprKind(static_cast(Record.readInt())); - FD->setUsesSEHTry(Record.readInt()); - FD->setHasSkippedBody(Record.readInt()); - FD->setIsMultiVersion(Record.readInt()); - FD->setLateTemplateParsed(Record.readInt()); - FD->setFriendConstraintRefersToEnclosingTemplate(Record.readInt()); - - FD->setCachedLinkage(static_cast(Record.readInt())); + const bool Pure = FunctionDeclBits.getNextBit(); + FD->setHasInheritedPrototype(FunctionDeclBits.getNextBit()); + FD->setHasWrittenPrototype(FunctionDeclBits.getNextBit()); + FD->setDeletedAsWritten(FunctionDeclBits.getNextBit()); + FD->setTrivial(FunctionDeclBits.getNextBit()); + FD->setTrivialForCall(FunctionDeclBits.getNextBit()); + FD->setDefaulted(FunctionDeclBits.getNextBit()); + FD->setExplicitlyDefaulted(FunctionDeclBits.getNextBit()); + FD->setIneligibleOrNotSelected(FunctionDeclBits.getNextBit()); + FD->setHasImplicitReturnZero(FunctionDeclBits.getNextBit()); + FD->setConstexprKind( + (ConstexprSpecKind)FunctionDeclBits.getNextBits(/*Width=*/2)); + FD->setUsesSEHTry(FunctionDeclBits.getNextBit()); + FD->setHasSkippedBody(FunctionDeclBits.getNextBit()); + FD->setIsMultiVersion(FunctionDeclBits.getNextBit()); + FD->setLateTemplateParsed(FunctionDeclBits.getNextBit()); + FD->setFriendConstraintRefersToEnclosingTemplate( + FunctionDeclBits.getNextBit()); + FD->setCachedLinkage((Linkage)FunctionDeclBits.getNextBits(/*Width=*/3)); + FD->EndRangeLoc = readSourceLocation(); FD->setDefaultLoc(readSourceLocation()); @@ -1575,26 +1590,29 @@ ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) { RedeclarableResult Redecl = VisitRedeclarable(VD); VisitDeclaratorDecl(VD); - VD->VarDeclBits.SClass = (StorageClass)Record.readInt(); - VD->VarDeclBits.TSCSpec = Record.readInt(); - VD->VarDeclBits.InitStyle = Record.readInt(); - VD->VarDeclBits.ARCPseudoStrong = Record.readInt(); + BitsUnpacker VarDeclBits(Record.readInt()); + VD->VarDeclBits.SClass = (StorageClass)VarDeclBits.getNextBits(/*Width=*/3); + VD->VarDeclBits.TSCSpec = VarDeclBits.getNextBits(/*Width=*/2); + VD->VarDeclBits.InitStyle = VarDeclBits.getNextBits(/*Width=*/2); + VD->VarDeclBits.ARCPseudoStrong = VarDeclBits.getNextBit(); bool HasDeducedType = false; if (!isa(VD)) { VD->NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = - Record.readInt(); - VD->NonParmVarDeclBits.ExceptionVar = Record.readInt(); - VD->NonParmVarDeclBits.NRVOVariable = Record.readInt(); - VD->NonParmVarDeclBits.CXXForRangeDecl = Record.readInt(); - VD->NonParmVarDeclBits.ObjCForDecl = Record.readInt(); - VD->NonParmVarDeclBits.IsInline = Record.readInt(); - VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt(); - VD->NonParmVarDeclBits.IsConstexpr = Record.readInt(); - VD->NonParmVarDeclBits.IsInitCapture = Record.readInt(); - VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record.readInt(); - VD->NonParmVarDeclBits.ImplicitParamKind = Record.readInt(); - VD->NonParmVarDeclBits.EscapingByref = Record.readInt(); - HasDeducedType = Record.readInt(); + VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.ExceptionVar = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.NRVOVariable = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.CXXForRangeDecl = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.ObjCForDecl = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.IsInline = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.IsInlineSpecified = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.IsConstexpr = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.IsInitCapture = VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = + VarDeclBits.getNextBit(); + VD->NonParmVarDeclBits.ImplicitParamKind = + VarDeclBits.getNextBits(/*Width*/ 3); + VD->NonParmVarDeclBits.EscapingByref = VarDeclBits.getNextBit(); + HasDeducedType = VarDeclBits.getNextBit(); } // If this variable has a deduced type, defer reading that type until we are @@ -1606,7 +1624,7 @@ ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) { VD->setType(Reader.GetType(DeferredTypeID)); DeferredTypeID = 0; - auto VarLinkage = static_cast(Record.readInt()); + auto VarLinkage = Linkage(VarDeclBits.getNextBits(/*Width=*/3)); VD->setCachedLinkage(VarLinkage); // Reconstruct the one piece of the IdentifierNamespace that we need. @@ -1614,18 +1632,18 @@ ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) { VD->getLexicalDeclContext()->isFunctionOrMethod()) VD->setLocalExternDecl(); + if (VarDeclBits.getNextBit()) { + Reader.DefinitionSource[VD] = + Loc.F->Kind == ModuleKind::MK_MainFile || + Reader.getContext().getLangOpts().BuildingPCHWithObjectFile; + } + if (VD->hasAttr()) { Expr *CopyExpr = Record.readExpr(); if (CopyExpr) Reader.getContext().setBlockVarCopyInit(VD, CopyExpr, Record.readInt()); } - if (Record.readInt()) { - Reader.DefinitionSource[VD] = - Loc.F->Kind == ModuleKind::MK_MainFile || - Reader.getContext().getLangOpts().BuildingPCHWithObjectFile; - } - enum VarKind { VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization }; @@ -1679,9 +1697,11 @@ void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) { void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) { VisitVarDecl(PD); - unsigned isObjCMethodParam = Record.readInt(); - unsigned scopeDepth = Record.readInt(); - unsigned scopeIndex = Record.readInt(); + + BitsUnpacker ParmVarDeclBits(Record.readInt()); + unsigned isObjCMethodParam = ParmVarDeclBits.getNextBit(); + unsigned scopeDepth = ParmVarDeclBits.getNextBits(/*Width=*/7); + unsigned scopeIndex = ParmVarDeclBits.getNextBits(/*Width=*/8); unsigned declQualifier = Record.readInt(); if (isObjCMethodParam) { assert(scopeDepth == 0); @@ -1690,9 +1710,10 @@ void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) { } else { PD->setScopeInfo(scopeDepth, scopeIndex); } - PD->ParmVarDeclBits.IsKNRPromoted = Record.readInt(); - PD->ParmVarDeclBits.HasInheritedDefaultArg = Record.readInt(); - if (Record.readInt()) // hasUninstantiatedDefaultArg. + PD->ParmVarDeclBits.IsKNRPromoted = ParmVarDeclBits.getNextBit(); + + PD->ParmVarDeclBits.HasInheritedDefaultArg = ParmVarDeclBits.getNextBit(); + if (ParmVarDeclBits.getNextBit()) // hasUninstantiatedDefaultArg. PD->setUninstantiatedDefaultArg(Record.readExpr()); PD->ExplicitObjectParameterIntroducerLoc = Record.readSourceLocation(); @@ -1791,8 +1812,10 @@ void ASTDeclReader::VisitLabelDecl(LabelDecl *D) { void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) { RedeclarableResult Redecl = VisitRedeclarable(D); VisitNamedDecl(D); - D->setInline(Record.readInt()); - D->setNested(Record.readInt()); + + BitsUnpacker NamespaceDeclBits(Record.readInt()); + D->setInline(NamespaceDeclBits.getNextBit()); + D->setNested(NamespaceDeclBits.getNextBit()); D->LocStart = readSourceLocation(); D->RBraceLoc = readSourceLocation(); @@ -1927,8 +1950,16 @@ void ASTDeclReader::VisitUnresolvedUsingIfExistsDecl( void ASTDeclReader::ReadCXXDefinitionData( struct CXXRecordDecl::DefinitionData &Data, const CXXRecordDecl *D, Decl *LambdaContext, unsigned IndexInLambdaContext) { -#define FIELD(Name, Width, Merge) Data.Name = Record.readInt(); + + BitsUnpacker CXXRecordDeclBits = Record.readInt(); + +#define FIELD(Name, Width, Merge) \ + if (!CXXRecordDeclBits.canGetNextNBits(Width)) \ + CXXRecordDeclBits.updateValue(Record.readInt()); \ + Data.Name = CXXRecordDeclBits.getNextBits(Width); + #include "clang/AST/CXXRecordDeclDefinitionBits.def" +#undef FIELD // Note: the caller has deserialized the IsLambda bit already. Data.ODRHash = Record.readInt(); @@ -1963,12 +1994,15 @@ void ASTDeclReader::ReadCXXDefinitionData( using Capture = LambdaCapture; auto &Lambda = static_cast(Data); - Lambda.DependencyKind = Record.readInt(); - Lambda.IsGenericLambda = Record.readInt(); - Lambda.CaptureDefault = Record.readInt(); - Lambda.NumCaptures = Record.readInt(); + + BitsUnpacker LambdaBits(Record.readInt()); + Lambda.DependencyKind = LambdaBits.getNextBits(/*Width=*/2); + Lambda.IsGenericLambda = LambdaBits.getNextBit(); + Lambda.CaptureDefault = LambdaBits.getNextBits(/*Width=*/2); + Lambda.NumCaptures = LambdaBits.getNextBits(/*Width=*/15); + Lambda.HasKnownInternalLinkage = LambdaBits.getNextBit(); + Lambda.NumExplicitCaptures = Record.readInt(); - Lambda.HasKnownInternalLinkage = Record.readInt(); Lambda.ManglingNumber = Record.readInt(); if (unsigned DeviceManglingNumber = Record.readInt()) Reader.getContext().DeviceLambdaManglingNumbers[D] = DeviceManglingNumber; @@ -1983,8 +2017,10 @@ void ASTDeclReader::ReadCXXDefinitionData( Lambda.MethodTyInfo = readTypeSourceInfo(); for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { SourceLocation Loc = readSourceLocation(); - bool IsImplicit = Record.readInt(); - auto Kind = static_cast(Record.readInt()); + BitsUnpacker CaptureBits(Record.readInt()); + bool IsImplicit = CaptureBits.getNextBit(); + auto Kind = + static_cast(CaptureBits.getNextBits(/*Width=*/3)); switch (Kind) { case LCK_StarThis: case LCK_This: diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 99358004ffd21..2fe12f7ff300f 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -5996,11 +5996,17 @@ void ASTRecordWriter::AddCXXCtorInitializers( void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { auto &Data = D->data(); + Record->push_back(Data.IsLambda); - #define FIELD(Name, Width, Merge) \ - Record->push_back(Data.Name); - #include "clang/AST/CXXRecordDeclDefinitionBits.def" + BitsPacker DefinitionBits; + +#define FIELD(Name, Width, Merge) DefinitionBits.addBits(Data.Name, Width); +#include "clang/AST/CXXRecordDeclDefinitionBits.def" +#undef FIELD + + while (DefinitionBits.hasUnconsumedValues()) + Record->push_back(DefinitionBits.getNextValue()); // getODRHash will compute the ODRHash if it has not been previously computed. Record->push_back(D->getODRHash()); @@ -6032,12 +6038,16 @@ void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { AddDeclRef(D->getFirstFriend()); } else { auto &Lambda = D->getLambdaData(); - Record->push_back(Lambda.DependencyKind); - Record->push_back(Lambda.IsGenericLambda); - Record->push_back(Lambda.CaptureDefault); - Record->push_back(Lambda.NumCaptures); + + BitsPacker LambdaBits; + LambdaBits.addBits(Lambda.DependencyKind, /*Width=*/2); + LambdaBits.addBit(Lambda.IsGenericLambda); + LambdaBits.addBits(Lambda.CaptureDefault, /*Width=*/2); + LambdaBits.addBits(Lambda.NumCaptures, /*Width=*/15); + LambdaBits.addBit(Lambda.HasKnownInternalLinkage); + Record->push_back(LambdaBits.getNextValue()); + Record->push_back(Lambda.NumExplicitCaptures); - Record->push_back(Lambda.HasKnownInternalLinkage); Record->push_back(Lambda.ManglingNumber); Record->push_back(D->getDeviceLambdaManglingNumber()); // The lambda context declaration and index within the context are provided @@ -6046,8 +6056,10 @@ void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { const LambdaCapture &Capture = Lambda.Captures.front()[I]; AddSourceLocation(Capture.getLocation()); - Record->push_back(Capture.isImplicit()); - Record->push_back(Capture.getCaptureKind()); + BitsPacker CaptureBits; + CaptureBits.addBit(Capture.isImplicit()); + CaptureBits.addBits(Capture.getCaptureKind(), /*Width=*/3); + Record->push_back(CaptureBits); switch (Capture.getCaptureKind()) { case LCK_StarThis: case LCK_This: diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp index ef28e69abc4e1..b4438e4cf6a0c 100644 --- a/clang/lib/Serialization/ASTWriterDecl.cpp +++ b/clang/lib/Serialization/ASTWriterDecl.cpp @@ -325,16 +325,21 @@ void ASTDeclWriter::VisitDecl(Decl *D) { Record.AddDeclRef(cast_or_null(D->getLexicalDeclContext())); else Record.push_back(0); - Record.push_back(D->isInvalidDecl()); - Record.push_back(D->hasAttrs()); + + BitsPacker DeclBits; + DeclBits.addBit(D->isInvalidDecl()); + DeclBits.addBit(D->hasAttrs()); + DeclBits.addBit(D->isImplicit()); + DeclBits.addBit(D->isUsed(false)); + DeclBits.addBit(D->isReferenced()); + DeclBits.addBit(D->isTopLevelDeclInObjCContainer()); + DeclBits.addBits(D->getAccess(), /*BitWidth=*/2); + DeclBits.addBits((uint64_t)D->getModuleOwnershipKind(), /*BitWidth=*/3); + Record.push_back(DeclBits); + if (D->hasAttrs()) Record.AddAttributes(D->getAttrs()); - Record.push_back(D->isImplicit()); - Record.push_back(D->isUsed(false)); - Record.push_back(D->isReferenced()); - Record.push_back(D->isTopLevelDeclInObjCContainer()); - Record.push_back(D->getAccess()); - Record.push_back((uint64_t)D->getModuleOwnershipKind()); + Record.push_back(Writer.getSubmoduleID(D->getOwningModule())); // If this declaration injected a name into a context different from its @@ -438,12 +443,15 @@ void ASTDeclWriter::VisitTagDecl(TagDecl *D) { VisitRedeclarable(D); VisitTypeDecl(D); Record.push_back(D->getIdentifierNamespace()); - Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding - if (!isa(D)) - Record.push_back(D->isCompleteDefinition()); - Record.push_back(D->isEmbeddedInDeclarator()); - Record.push_back(D->isFreeStanding()); - Record.push_back(D->isCompleteDefinitionRequired()); + + BitsPacker TagDeclBits; + TagDeclBits.addBits(D->getTagKind(), /*BitWidth=*/3); + TagDeclBits.addBit(!isa(D) ? D->isCompleteDefinition() : 0); + TagDeclBits.addBit(D->isEmbeddedInDeclarator()); + TagDeclBits.addBit(D->isFreeStanding()); + TagDeclBits.addBit(D->isCompleteDefinitionRequired()); + Record.push_back(TagDeclBits); + Record.AddSourceRange(D->getBraceRange()); if (D->hasExtInfo()) { @@ -468,11 +476,15 @@ void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) { if (!D->getIntegerTypeSourceInfo()) Record.AddTypeRef(D->getIntegerType()); Record.AddTypeRef(D->getPromotionType()); - Record.push_back(D->getNumPositiveBits()); - Record.push_back(D->getNumNegativeBits()); - Record.push_back(D->isScoped()); - Record.push_back(D->isScopedUsingClassTag()); - Record.push_back(D->isFixed()); + + BitsPacker EnumDeclBits; + EnumDeclBits.addBits(D->getNumPositiveBits(), /*BitWidth=*/8); + EnumDeclBits.addBits(D->getNumNegativeBits(), /*BitWidth=*/8); + EnumDeclBits.addBit(D->isScoped()); + EnumDeclBits.addBit(D->isScopedUsingClassTag()); + EnumDeclBits.addBit(D->isFixed()); + Record.push_back(EnumDeclBits); + Record.push_back(D->getODRHash()); if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) { @@ -511,18 +523,22 @@ void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) { "RecordDeclBits"); VisitTagDecl(D); - Record.push_back(D->hasFlexibleArrayMember()); - Record.push_back(D->isAnonymousStructOrUnion()); - Record.push_back(D->hasObjectMember()); - Record.push_back(D->hasVolatileMember()); - Record.push_back(D->isNonTrivialToPrimitiveDefaultInitialize()); - Record.push_back(D->isNonTrivialToPrimitiveCopy()); - Record.push_back(D->isNonTrivialToPrimitiveDestroy()); - Record.push_back(D->hasNonTrivialToPrimitiveDefaultInitializeCUnion()); - Record.push_back(D->hasNonTrivialToPrimitiveDestructCUnion()); - Record.push_back(D->hasNonTrivialToPrimitiveCopyCUnion()); - Record.push_back(D->isParamDestroyedInCallee()); - Record.push_back(llvm::to_underlying(D->getArgPassingRestrictions())); + + BitsPacker RecordDeclBits; + RecordDeclBits.addBit(D->hasFlexibleArrayMember()); + RecordDeclBits.addBit(D->isAnonymousStructOrUnion()); + RecordDeclBits.addBit(D->hasObjectMember()); + RecordDeclBits.addBit(D->hasVolatileMember()); + RecordDeclBits.addBit(D->isNonTrivialToPrimitiveDefaultInitialize()); + RecordDeclBits.addBit(D->isNonTrivialToPrimitiveCopy()); + RecordDeclBits.addBit(D->isNonTrivialToPrimitiveDestroy()); + RecordDeclBits.addBit(D->hasNonTrivialToPrimitiveDefaultInitializeCUnion()); + RecordDeclBits.addBit(D->hasNonTrivialToPrimitiveDestructCUnion()); + RecordDeclBits.addBit(D->hasNonTrivialToPrimitiveCopyCUnion()); + RecordDeclBits.addBit(D->isParamDestroyedInCallee()); + RecordDeclBits.addBits(llvm::to_underlying(D->getArgPassingRestrictions()), 2); + Record.push_back(RecordDeclBits); + // Only compute this for C/Objective-C, in C++ this is computed as part // of CXXRecordDecl. if (!isa(D)) @@ -660,30 +676,31 @@ void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) { Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName()); Record.push_back(D->getIdentifierNamespace()); - // FunctionDecl's body is handled last at ASTWriterDecl::Visit, - // after everything else is written. - Record.push_back( - static_cast(D->getStorageClass())); // FIXME: stable encoding - Record.push_back(D->isInlineSpecified()); - Record.push_back(D->isInlined()); - Record.push_back(D->isVirtualAsWritten()); - Record.push_back(D->isPure()); - Record.push_back(D->hasInheritedPrototype()); - Record.push_back(D->hasWrittenPrototype()); - Record.push_back(D->isDeletedBit()); - Record.push_back(D->isTrivial()); - Record.push_back(D->isTrivialForCall()); - Record.push_back(D->isDefaulted()); - Record.push_back(D->isExplicitlyDefaulted()); - Record.push_back(D->isIneligibleOrNotSelected()); - Record.push_back(D->hasImplicitReturnZero()); - Record.push_back(static_cast(D->getConstexprKind())); - Record.push_back(D->usesSEHTry()); - Record.push_back(D->hasSkippedBody()); - Record.push_back(D->isMultiVersion()); - Record.push_back(D->isLateTemplateParsed()); - Record.push_back(D->FriendConstraintRefersToEnclosingTemplate()); - Record.push_back(llvm::to_underlying(D->getLinkageInternal())); + BitsPacker FunctionDeclBits; + // FIXME: stable encoding + FunctionDeclBits.addBits((uint32_t)D->getStorageClass(), /*BitWidth=*/3); + FunctionDeclBits.addBit(D->isInlineSpecified()); + FunctionDeclBits.addBit(D->isInlined()); + FunctionDeclBits.addBit(D->isVirtualAsWritten()); + FunctionDeclBits.addBit(D->isPure()); + FunctionDeclBits.addBit(D->hasInheritedPrototype()); + FunctionDeclBits.addBit(D->hasWrittenPrototype()); + FunctionDeclBits.addBit(D->isDeletedBit()); + FunctionDeclBits.addBit(D->isTrivial()); + FunctionDeclBits.addBit(D->isTrivialForCall()); + FunctionDeclBits.addBit(D->isDefaulted()); + FunctionDeclBits.addBit(D->isExplicitlyDefaulted()); + FunctionDeclBits.addBit(D->isIneligibleOrNotSelected()); + FunctionDeclBits.addBit(D->hasImplicitReturnZero()); + FunctionDeclBits.addBits((uint64_t)(D->getConstexprKind()), /*BitWidth=*/2); + FunctionDeclBits.addBit(D->usesSEHTry()); + FunctionDeclBits.addBit(D->hasSkippedBody()); + FunctionDeclBits.addBit(D->isMultiVersion()); + FunctionDeclBits.addBit(D->isLateTemplateParsed()); + FunctionDeclBits.addBit(D->FriendConstraintRefersToEnclosingTemplate()); + FunctionDeclBits.addBits(llvm::to_underlying(D->getLinkageInternal()), 3); + Record.push_back(FunctionDeclBits); + Record.AddSourceLocation(D->getEndLoc()); Record.AddSourceLocation(D->getDefaultLoc()); @@ -1043,38 +1060,37 @@ void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { void ASTDeclWriter::VisitVarDecl(VarDecl *D) { VisitRedeclarable(D); VisitDeclaratorDecl(D); - Record.push_back(D->getStorageClass()); - Record.push_back(D->getTSCSpec()); - Record.push_back(D->getInitStyle()); - Record.push_back(D->isARCPseudoStrong()); + + BitsPacker VarDeclBits; + VarDeclBits.addBits(D->getStorageClass(), /*BitWidth=*/3); + VarDeclBits.addBits(D->getTSCSpec(), /*BitWidth=*/2); + VarDeclBits.addBits(D->getInitStyle(), /*BitWidth=*/2); + VarDeclBits.addBit(D->isARCPseudoStrong()); + bool HasDeducedType = false; if (!isa(D)) { - Record.push_back(D->isThisDeclarationADemotedDefinition()); - Record.push_back(D->isExceptionVariable()); - Record.push_back(D->isNRVOVariable()); - Record.push_back(D->isCXXForRangeDecl()); - Record.push_back(D->isObjCForDecl()); - Record.push_back(D->isInline()); - Record.push_back(D->isInlineSpecified()); - Record.push_back(D->isConstexpr()); - Record.push_back(D->isInitCapture()); - Record.push_back(D->isPreviousDeclInSameBlockScope()); + VarDeclBits.addBit(D->isThisDeclarationADemotedDefinition()); + VarDeclBits.addBit(D->isExceptionVariable()); + VarDeclBits.addBit(D->isNRVOVariable()); + VarDeclBits.addBit(D->isCXXForRangeDecl()); + VarDeclBits.addBit(D->isObjCForDecl()); + VarDeclBits.addBit(D->isInline()); + VarDeclBits.addBit(D->isInlineSpecified()); + VarDeclBits.addBit(D->isConstexpr()); + VarDeclBits.addBit(D->isInitCapture()); + VarDeclBits.addBit(D->isPreviousDeclInSameBlockScope()); + if (const auto *IPD = dyn_cast(D)) - Record.push_back(static_cast(IPD->getParameterKind())); + VarDeclBits.addBits(IPD->getParameterKind(), /*Width=*/3); else - Record.push_back(0); - Record.push_back(D->isEscapingByref()); + VarDeclBits.addBits(0, /*Width=*/3); + + VarDeclBits.addBit(D->isEscapingByref()); HasDeducedType = D->getType()->getContainedDeducedType(); - Record.push_back(HasDeducedType); + VarDeclBits.addBit(HasDeducedType); } - Record.push_back(llvm::to_underlying(D->getLinkageInternal())); - if (D->hasAttr()) { - BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D); - Record.AddStmt(Init.getCopyExpr()); - if (Init.getCopyExpr()) - Record.push_back(Init.canThrow()); - } + VarDeclBits.addBits(llvm::to_underlying(D->getLinkageInternal()), /*BitWidth=*/3); bool ModulesCodegen = false; if (Writer.WritingModule && D->getStorageDuration() == SD_Static && @@ -1089,10 +1105,20 @@ void ASTDeclWriter::VisitVarDecl(VarDecl *D) { Writer.Context->getLangOpts().BuildingPCHWithObjectFile)) && Writer.Context->GetGVALinkageForVariable(D) >= GVA_StrongExternal; } - Record.push_back(ModulesCodegen); + + VarDeclBits.addBit(ModulesCodegen); + Record.push_back(VarDeclBits); + if (ModulesCodegen) Writer.ModularCodegenDecls.push_back(Writer.GetDeclRef(D)); + if (D->hasAttr()) { + BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D); + Record.AddStmt(Init.getCopyExpr()); + if (Init.getCopyExpr()) + Record.push_back(Init.canThrow()); + } + enum { VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization }; @@ -1144,13 +1170,17 @@ void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) { void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) { VisitVarDecl(D); - Record.push_back(D->isObjCMethodParameter()); - Record.push_back(D->getFunctionScopeDepth()); - Record.push_back(D->getFunctionScopeIndex()); + + BitsPacker ParmVarDeclBits; + ParmVarDeclBits.addBit(D->isObjCMethodParameter()); + ParmVarDeclBits.addBits(D->getFunctionScopeDepth(), /*BitsWidth=*/7); + ParmVarDeclBits.addBits(D->getFunctionScopeIndex(), /*BitsWidth=*/8); + ParmVarDeclBits.addBit(D->isKNRPromoted()); + ParmVarDeclBits.addBit(D->hasInheritedDefaultArg()); + ParmVarDeclBits.addBit(D->hasUninstantiatedDefaultArg()); + Record.push_back(ParmVarDeclBits); + Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding - Record.push_back(D->isKNRPromoted()); - Record.push_back(D->hasInheritedDefaultArg()); - Record.push_back(D->hasUninstantiatedDefaultArg()); if (D->hasUninstantiatedDefaultArg()) Record.AddStmt(D->getUninstantiatedDefaultArg()); Record.AddSourceLocation(D->getExplicitObjectParamThisLoc()); @@ -1295,8 +1325,12 @@ void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) { void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) { VisitRedeclarable(D); VisitNamedDecl(D); - Record.push_back(D->isInline()); - Record.push_back(D->isNested()); + + BitsPacker NamespaceDeclBits; + NamespaceDeclBits.addBit(D->isInline()); + NamespaceDeclBits.addBit(D->isNested()); + Record.push_back(NamespaceDeclBits); + Record.AddSourceLocation(D->getBeginLoc()); Record.AddSourceLocation(D->getRBraceLoc()); @@ -2005,14 +2039,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(0)); // isImplicit - Abv->Add(BitCodeAbbrevOp(0)); // isUsed - Abv->Add(BitCodeAbbrevOp(0)); // isReferenced - Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier @@ -2038,14 +2069,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(0)); // isImplicit - Abv->Add(BitCodeAbbrevOp(0)); // isUsed - Abv->Add(BitCodeAbbrevOp(0)); // isReferenced - Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier @@ -2076,14 +2104,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(0)); // isImplicit - Abv->Add(BitCodeAbbrevOp(0)); // isUsed - Abv->Add(BitCodeAbbrevOp(0)); // isReferenced - Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer - Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier @@ -2094,11 +2119,10 @@ void ASTWriter::WriteDeclAbbrevs() { Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref // TagDecl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 7)); // Packed Tag Decl Bits: getTagKind, isCompleteDefinition, + // EmbeddedInDeclarator, IsFreeStanding, isCompleteDefinitionRequired Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind @@ -2106,11 +2130,7 @@ void ASTWriter::WriteDeclAbbrevs() { Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed + Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 19)); // Enum Decl Bits Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));// ODRHash Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum // DC @@ -2126,14 +2146,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(0)); // isImplicit - Abv->Add(BitCodeAbbrevOp(0)); // isUsed - Abv->Add(BitCodeAbbrevOp(0)); // isReferenced - Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer - Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier @@ -2144,36 +2161,24 @@ void ASTWriter::WriteDeclAbbrevs() { Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref // TagDecl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 7)); // Packed Tag Decl Bits: getTagKind, isCompleteDefinition, + // EmbeddedInDeclarator, IsFreeStanding, isCompleteDefinitionRequired Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind // RecordDecl - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember - - // isNonTrivialToPrimitiveDefaultInitialize - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); - // isNonTrivialToPrimitiveCopy - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); - // isNonTrivialToPrimitiveDestroy - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); - // hasNonTrivialToPrimitiveDefaultInitializeCUnion - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); - // hasNonTrivialToPrimitiveDestructCUnion - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); - // hasNonTrivialToPrimitiveCopyCUnion - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); - // isParamDestroyedInCallee - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); - // getArgPassingRestrictions - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 13)); // Packed Record Decl Bits: FlexibleArrayMember, + // AnonymousStructUnion, hasObjectMember, hasVolatileMember, + // isNonTrivialToPrimitiveDefaultInitialize, + // isNonTrivialToPrimitiveCopy, isNonTrivialToPrimitiveDestroy, + // hasNonTrivialToPrimitiveDefaultInitializeCUnion, + // hasNonTrivialToPrimitiveDestructCUnion, + // hasNonTrivialToPrimitiveCopyCUnion, isParamDestroyedInCallee, + // getArgPassingRestrictions // ODRHash Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 26)); @@ -2190,14 +2195,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(0)); // isImplicit - Abv->Add(BitCodeAbbrevOp(0)); // isUsed - Abv->Add(BitCodeAbbrevOp(0)); // isReferenced - Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer - Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier @@ -2210,20 +2212,17 @@ void ASTWriter::WriteDeclAbbrevs() { Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType // VarDecl - Abv->Add(BitCodeAbbrevOp(0)); // SClass - Abv->Add(BitCodeAbbrevOp(0)); // TSCSpec - Abv->Add(BitCodeAbbrevOp(0)); // InitStyle - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong - Abv->Add(BitCodeAbbrevOp(1)); // Linkage::None - Abv->Add(BitCodeAbbrevOp(0)); // ModulesCodegen - Abv->Add(BitCodeAbbrevOp(0)); // VarKind (local enum) + Abv->Add( + BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, + 12)); // Packed Var Decl bits: SClass, TSCSpec, InitStyle, + // isARCPseudoStrong, Linkage, ModulesCodegen + Abv->Add(BitCodeAbbrevOp(0)); // VarKind (local enum) // ParmVarDecl - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter - Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 19)); // Packed Parm Var Decl bits: IsObjCMethodParameter, ScopeDepth, + // ScopeIndex, KNRPromoted, HasInheritedDefaultArg Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier - Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted - Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg // Type Source Info Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); @@ -2238,14 +2237,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(0)); // isImplicit - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced - Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier @@ -2267,14 +2263,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(0)); // isImplicit - Abv->Add(BitCodeAbbrevOp(0)); // isUsed - Abv->Add(BitCodeAbbrevOp(0)); // isReferenced - Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer - Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier @@ -2287,25 +2280,14 @@ void ASTWriter::WriteDeclAbbrevs() { Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType // VarDecl - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // SClass - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // TSCSpec - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // InitStyle - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsThisDeclarationADemotedDefinition - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isObjCForDecl - Abv->Add(BitCodeAbbrevOp(0)); // isInline - Abv->Add(BitCodeAbbrevOp(0)); // isInlineSpecified - Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr - Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture - Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope - Abv->Add(BitCodeAbbrevOp(0)); // ImplicitParamKind - Abv->Add(BitCodeAbbrevOp(0)); // EscapingByref - Abv->Add(BitCodeAbbrevOp(0)); // HasDeducedType - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage - Abv->Add(BitCodeAbbrevOp(0)); // ModulesCodeGen + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 27)); // Packed Var Decl bits: SClass, TSCSpec, InitStyle, + // isARCPseudoStrong, IsThisDeclarationADemotedDefinition, + // isExceptionVariable, isNRVOVariable, isCXXForRangeDecl, + // isObjCForDecl, isInline, isInlineSpecified, isConstexpr, + // isInitCapture, isPrevDeclInSameScope, ImplicitParamKind, + // EscapingByref, HasDeducedType, Linkage, ModulesCodegen Abv->Add(BitCodeAbbrevOp(0)); // VarKind (local enum) // Type Source Info Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); @@ -2322,14 +2304,11 @@ void ASTWriter::WriteDeclAbbrevs() { // Decl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext - Abv->Add(BitCodeAbbrevOp(0)); // Invalid - Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced - Abv->Add(BitCodeAbbrevOp(0)); // InObjCContainer - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 11)); // Packed DeclBits: isInvalidDecl, HasAttrs, isImplicit, isUsed, + // isReferenced, TopLevelDeclInObjCContainer, AccessSpecifier, + // ModuleOwnershipKind Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID // NamedDecl Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind @@ -2343,27 +2322,14 @@ void ASTWriter::WriteDeclAbbrevs() { Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType // FunctionDecl Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure - Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedProto - Abv->Add(BitCodeAbbrevOp(1)); // HasWrittenProto - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // TrivialForCall - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsIneligibleOrNotSelected - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Constexpr - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FriendConstraintRefersToEnclosingTemplate - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage + Abv->Add(BitCodeAbbrevOp( + BitCodeAbbrevOp::Fixed, + 27)); // Packed Function Bits: StorageClass, Inline, InlineSpecified, + // VirtualAsWritten, Pure, HasInheritedProto, HasWrittenProto, + // Deleted, Trivial, TrivialForCall, Defaulted, ExplicitlyDefaulted, + // IsIneligibleOrNotSelected, ImplicitReturnZero, Constexpr, + // UsesSEHTry, SkippedBody, MultiVersion, LateParsed, + // FriendConstraintRefersToEnclosingTemplate, Linkage Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LocEnd Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Default Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash diff --git a/clang/test/Modules/decl-params-determinisim.m b/clang/test/Modules/decl-params-determinisim.m index d7e873bb4938e..9eedf0a206423 100644 --- a/clang/test/Modules/decl-params-determinisim.m +++ b/clang/test/Modules/decl-params-determinisim.m @@ -22,23 +22,23 @@ /// op13 encodes the anonymous decl number which should be in order. // CHECK: