Index: include/clang/AST/Decl.h =================================================================== --- include/clang/AST/Decl.h +++ include/clang/AST/Decl.h @@ -3656,10 +3656,10 @@ bool hasObjectMember() const { return RecordDeclBits.HasObjectMember; } void setHasObjectMember(bool val) { RecordDeclBits.HasObjectMember = val; } - bool hasVolatileMember() const { return RecordDeclBits.HasVolatileMember; } + bool hasVolatileSubobject() const { return RecordDeclBits.HasVolatileSubobject; } - void setHasVolatileMember(bool val) { - RecordDeclBits.HasVolatileMember = val; + void setHasVolatileSubobject(bool val) { + RecordDeclBits.HasVolatileSubobject = val; } bool hasLoadedFieldsFromExternalStorage() const { Index: include/clang/AST/DeclBase.h =================================================================== --- include/clang/AST/DeclBase.h +++ include/clang/AST/DeclBase.h @@ -1426,9 +1426,9 @@ /// containing an Objective-C object pointer type. uint64_t HasObjectMember : 1; - /// This is true if struct has at least one member of - /// 'volatile' type. - uint64_t HasVolatileMember : 1; + /// This is true if struct has at least one (possibly nested) member + /// of 'volatile' type. + uint64_t HasVolatileSubobject : 1; /// Whether the field declarations of this record have been loaded /// from external storage. To avoid unnecessary deserialization of Index: include/clang/AST/DeclCXX.h =================================================================== --- include/clang/AST/DeclCXX.h +++ include/clang/AST/DeclCXX.h @@ -399,7 +399,7 @@ unsigned HasPublicFields : 1; /// True if this class (or any subobject) has mutable fields. - unsigned HasMutableFields : 1; + unsigned HasMutableSubobject : 1; /// True if this class (or any nested anonymous struct or union) /// has variant members. @@ -1127,7 +1127,7 @@ /// Determine whether we need to eagerly declare a defaulted copy /// assignment operator for this class. bool needsOverloadResolutionForCopyAssignment() const { - return data().HasMutableFields; + return data().HasMutableSubobject; } /// Determine whether an implicit copy assignment operator for this @@ -1363,7 +1363,7 @@ /// Determine whether this class, or any of its class subobjects, /// contains a mutable field. - bool hasMutableFields() const { return data().HasMutableFields; } + bool hasMutableSubobject() const { return data().HasMutableSubobject; } /// Determine whether this class has any variant members. bool hasVariantMembers() const { return data().HasVariantMembers; } Index: lib/AST/ASTDumper.cpp =================================================================== --- lib/AST/ASTDumper.cpp +++ lib/AST/ASTDumper.cpp @@ -1409,7 +1409,7 @@ FLAG(hasUserDeclaredConstructor, has_user_declared_ctor); FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor); - FLAG(hasMutableFields, has_mutable_fields); + FLAG(hasMutableSubobject, has_mutable_subobject); FLAG(hasVariantMembers, has_variant_members); FLAG(allowConstDefaultInit, can_const_default_init); Index: lib/AST/ASTImporter.cpp =================================================================== --- lib/AST/ASTImporter.cpp +++ lib/AST/ASTImporter.cpp @@ -1340,7 +1340,7 @@ ToData.HasPrivateFields = FromData.HasPrivateFields; ToData.HasProtectedFields = FromData.HasProtectedFields; ToData.HasPublicFields = FromData.HasPublicFields; - ToData.HasMutableFields = FromData.HasMutableFields; + ToData.HasMutableSubobject = FromData.HasMutableSubobject; ToData.HasVariantMembers = FromData.HasVariantMembers; ToData.HasOnlyCMembers = FromData.HasOnlyCMembers; ToData.HasInClassInitializer = FromData.HasInClassInitializer; Index: lib/AST/Decl.cpp =================================================================== --- lib/AST/Decl.cpp +++ lib/AST/Decl.cpp @@ -4073,7 +4073,7 @@ setHasFlexibleArrayMember(false); setAnonymousStructOrUnion(false); setHasObjectMember(false); - setHasVolatileMember(false); + setHasVolatileSubobject(false); setHasLoadedFieldsFromExternalStorage(false); setNonTrivialToPrimitiveDefaultInitialize(false); setNonTrivialToPrimitiveCopy(false); Index: lib/AST/DeclCXX.cpp =================================================================== --- lib/AST/DeclCXX.cpp +++ lib/AST/DeclCXX.cpp @@ -77,7 +77,7 @@ Abstract(false), IsStandardLayout(true), IsCXX11StandardLayout(true), HasBasesWithFields(false), HasBasesWithNonStaticDataMembers(false), HasPrivateFields(false), HasProtectedFields(false), - HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false), + HasPublicFields(false), HasMutableSubobject(false), HasVariantMembers(false), HasOnlyCMembers(true), HasInClassInitializer(false), HasUninitializedReferenceMember(false), HasUninitializedFields(false), HasInheritedConstructor(false), HasInheritedAssignment(false), @@ -422,16 +422,16 @@ if (BaseClassDecl->hasObjectMember()) setHasObjectMember(true); - if (BaseClassDecl->hasVolatileMember()) - setHasVolatileMember(true); + if (BaseClassDecl->hasVolatileSubobject()) + setHasVolatileSubobject(true); if (BaseClassDecl->getArgPassingRestrictions() == RecordDecl::APK_CanNeverPassInRegs) setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs); // Keep track of the presence of mutable fields. - if (BaseClassDecl->hasMutableFields()) { - data().HasMutableFields = true; + if (BaseClassDecl->hasMutableSubobject()) { + data().HasMutableSubobject = true; data().NeedOverloadResolutionForCopyConstructor = true; } @@ -927,7 +927,7 @@ // Keep track of the presence of mutable fields. if (Field->isMutable()) { - data().HasMutableFields = true; + data().HasMutableSubobject = true; data().NeedOverloadResolutionForCopyConstructor = true; } @@ -1131,8 +1131,8 @@ data().HasIrrelevantDestructor = false; if (FieldRec->hasObjectMember()) setHasObjectMember(true); - if (FieldRec->hasVolatileMember()) - setHasVolatileMember(true); + if (FieldRec->hasVolatileSubobject()) + setHasVolatileSubobject(true); if (FieldRec->getArgPassingRestrictions() == RecordDecl::APK_CanNeverPassInRegs) setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs); @@ -1170,8 +1170,8 @@ } // Keep track of the presence of mutable fields. - if (FieldRec->hasMutableFields()) { - data().HasMutableFields = true; + if (FieldRec->hasMutableSubobject()) { + data().HasMutableSubobject = true; data().NeedOverloadResolutionForCopyConstructor = true; } Index: lib/AST/ExprConstant.cpp =================================================================== --- lib/AST/ExprConstant.cpp +++ lib/AST/ExprConstant.cpp @@ -2728,7 +2728,7 @@ if (!RD) return false; - if (!RD->hasMutableFields()) + if (!RD->hasMutableSubobject()) return false; for (auto *Field : RD->fields()) { Index: lib/CodeGen/CGAtomic.cpp =================================================================== --- lib/CodeGen/CGAtomic.cpp +++ lib/CodeGen/CGAtomic.cpp @@ -1448,7 +1448,7 @@ bool CodeGenFunction::LValueIsSuitableForInlineAtomic(LValue LV) { if (!CGM.getCodeGenOpts().MSVolatile) return false; AtomicInfo AI(*this, LV); - bool IsVolatile = LV.isVolatile() || hasVolatileMember(LV.getType()); + bool IsVolatile = LV.isVolatile() || hasVolatileSubobject(LV.getType()); // An atomic is inline if we don't need to use a libcall. bool AtomicIsInline = !AI.shouldUseLibcall(); // MSVC doesn't seem to do this for types wider than a pointer. Index: lib/CodeGen/CGBlocks.cpp =================================================================== --- lib/CodeGen/CGBlocks.cpp +++ lib/CodeGen/CGBlocks.cpp @@ -396,7 +396,7 @@ // Otherwise, we just have to make sure there aren't any mutable // fields that might have changed since initialization. - return !record->hasMutableFields(); + return !record->hasMutableSubobject(); } /// It is illegal to modify a const object after initialization. Index: lib/CodeGen/CGExpr.cpp =================================================================== --- lib/CodeGen/CGExpr.cpp +++ lib/CodeGen/CGExpr.cpp @@ -1373,7 +1373,7 @@ // mutable subobjects or non-trivial copy/destroy behavior. if (const auto *RT = dyn_cast(type)) if (const auto *RD = dyn_cast(RT->getDecl())) - if (RD->hasMutableFields() || !RD->isTrivial()) + if (RD->hasMutableSubobject() || !RD->isTrivial()) return false; return true; Index: lib/CodeGen/CGExprAgg.cpp =================================================================== --- lib/CodeGen/CGExprAgg.cpp +++ lib/CodeGen/CGExprAgg.cpp @@ -1161,7 +1161,7 @@ AggValueSlot::MayOverlap); // A non-volatile aggregate destination might have volatile member. if (!LHSSlot.isVolatile() && - CGF.hasVolatileMember(E->getLHS()->getType())) + CGF.hasVolatileSubobject(E->getLHS()->getType())) LHSSlot.setVolatile(true); CGF.EmitAggExpr(E->getRHS(), LHSSlot); Index: lib/CodeGen/CodeGenFunction.h =================================================================== --- lib/CodeGen/CodeGenFunction.h +++ lib/CodeGen/CodeGenFunction.h @@ -2281,12 +2281,12 @@ void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit); - /// hasVolatileMember - returns true if aggregate type has a volatile - /// member. - bool hasVolatileMember(QualType T) { + /// hasVolatileSubobject - returns true if aggregate type has a volatile + /// subobject. + bool hasVolatileSubobject(QualType T) { if (const RecordType *RT = T->getAs()) { const RecordDecl *RD = cast(RT->getDecl()); - return RD->hasVolatileMember(); + return RD->hasVolatileSubobject(); } return false; } @@ -2317,7 +2317,7 @@ /// Emit an aggregate assignment. void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy) { - bool IsVolatile = hasVolatileMember(EltTy); + bool IsVolatile = hasVolatileSubobject(EltTy); EmitAggregateCopy(Dest, Src, EltTy, AggValueSlot::MayOverlap, IsVolatile); } Index: lib/CodeGen/CodeGenModule.cpp =================================================================== --- lib/CodeGen/CodeGenModule.cpp +++ lib/CodeGen/CodeGenModule.cpp @@ -2863,7 +2863,7 @@ if (Context.getLangOpts().CPlusPlus) { if (const CXXRecordDecl *Record = Context.getBaseElementType(Ty)->getAsCXXRecordDecl()) - return ExcludeCtor && !Record->hasMutableFields() && + return ExcludeCtor && !Record->hasMutableSubobject() && Record->hasTrivialDestructor(); } @@ -3015,8 +3015,8 @@ !D->hasDefinition() && D->hasInit() && !D->hasAttr()) { const auto *Record = Context.getBaseElementType(D->getType())->getAsCXXRecordDecl(); - bool HasMutableFields = Record && Record->hasMutableFields(); - if (!HasMutableFields) { + bool HasMutableSubobject = Record && Record->hasMutableSubobject(); + if (!HasMutableSubobject) { const VarDecl *InitDecl; const Expr *InitExpr = D->getAnyInitializer(InitDecl); if (InitExpr) { Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp +++ lib/Sema/SemaDecl.cpp @@ -15724,8 +15724,8 @@ } if (Record && FDTTy->getDecl()->hasObjectMember()) Record->setHasObjectMember(true); - if (Record && FDTTy->getDecl()->hasVolatileMember()) - Record->setHasVolatileMember(true); + if (Record && FDTTy->getDecl()->hasVolatileSubobject()) + Record->setHasVolatileSubobject(true); } else if (FDTy->isObjCObjectType()) { /// A field cannot be an Objective-c object Diag(FD->getLocation(), diag::err_statically_allocated_object) @@ -15791,7 +15791,7 @@ } if (Record && FD->getType().isVolatileQualified()) - Record->setHasVolatileMember(true); + Record->setHasVolatileSubobject(true); // Keep track of the number of named members. if (FD->getIdentifier()) ++NumNamedMembers; Index: lib/Sema/SemaOpenMP.cpp =================================================================== --- lib/Sema/SemaOpenMP.cpp +++ lib/Sema/SemaOpenMP.cpp @@ -1107,7 +1107,7 @@ RD = CTD->getTemplatedDecl(); if (IsConstant && !(SemaRef.getLangOpts().CPlusPlus && RD && RD->hasDefinition() && - RD->hasMutableFields())) { + RD->hasMutableSubobject())) { // Variables with const-qualified type having no mutable member may be // listed in a firstprivate clause, even if they are static data members. DSAVarData DVarTemp = Index: lib/Serialization/ASTReaderDecl.cpp =================================================================== --- lib/Serialization/ASTReaderDecl.cpp +++ lib/Serialization/ASTReaderDecl.cpp @@ -787,7 +787,7 @@ RD->setHasFlexibleArrayMember(Record.readInt()); RD->setAnonymousStructOrUnion(Record.readInt()); RD->setHasObjectMember(Record.readInt()); - RD->setHasVolatileMember(Record.readInt()); + RD->setHasVolatileSubobject(Record.readInt()); RD->setNonTrivialToPrimitiveDefaultInitialize(Record.readInt()); RD->setNonTrivialToPrimitiveCopy(Record.readInt()); RD->setNonTrivialToPrimitiveDestroy(Record.readInt()); @@ -1651,7 +1651,7 @@ Data.HasPrivateFields = Record.readInt(); Data.HasProtectedFields = Record.readInt(); Data.HasPublicFields = Record.readInt(); - Data.HasMutableFields = Record.readInt(); + Data.HasMutableSubobject = Record.readInt(); Data.HasVariantMembers = Record.readInt(); Data.HasOnlyCMembers = Record.readInt(); Data.HasInClassInitializer = Record.readInt(); @@ -1792,7 +1792,7 @@ MATCH_FIELD(HasPrivateFields) MATCH_FIELD(HasProtectedFields) MATCH_FIELD(HasPublicFields) - MATCH_FIELD(HasMutableFields) + MATCH_FIELD(HasMutableSubobject) MATCH_FIELD(HasVariantMembers) MATCH_FIELD(HasOnlyCMembers) MATCH_FIELD(HasInClassInitializer) Index: lib/Serialization/ASTWriter.cpp =================================================================== --- lib/Serialization/ASTWriter.cpp +++ lib/Serialization/ASTWriter.cpp @@ -6025,7 +6025,7 @@ Record->push_back(Data.HasPrivateFields); Record->push_back(Data.HasProtectedFields); Record->push_back(Data.HasPublicFields); - Record->push_back(Data.HasMutableFields); + Record->push_back(Data.HasMutableSubobject); Record->push_back(Data.HasVariantMembers); Record->push_back(Data.HasOnlyCMembers); Record->push_back(Data.HasInClassInitializer); Index: lib/Serialization/ASTWriterDecl.cpp =================================================================== --- lib/Serialization/ASTWriterDecl.cpp +++ lib/Serialization/ASTWriterDecl.cpp @@ -468,7 +468,7 @@ Record.push_back(D->hasFlexibleArrayMember()); Record.push_back(D->isAnonymousStructOrUnion()); Record.push_back(D->hasObjectMember()); - Record.push_back(D->hasVolatileMember()); + Record.push_back(D->hasVolatileSubobject()); Record.push_back(D->isNonTrivialToPrimitiveDefaultInitialize()); Record.push_back(D->isNonTrivialToPrimitiveCopy()); Record.push_back(D->isNonTrivialToPrimitiveDestroy()); @@ -1920,7 +1920,7 @@ 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 + Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileSubobject // isNonTrivialToPrimitiveDefaultInitialize Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); Index: lib/StaticAnalyzer/Core/CallEvent.cpp =================================================================== --- lib/StaticAnalyzer/Core/CallEvent.cpp +++ lib/StaticAnalyzer/Core/CallEvent.cpp @@ -675,7 +675,7 @@ T = T->getPointeeType(); const CXXRecordDecl *ParentRecord = T->getAsCXXRecordDecl(); assert(ParentRecord); - if (ParentRecord->hasMutableFields()) + if (ParentRecord->hasMutableSubobject()) return; // Preserve CXXThis. const MemRegion *ThisRegion = ThisVal.getAsRegion();