diff --git a/src/google/protobuf/extension_set.cc b/src/google/protobuf/extension_set.cc index 12a730ce1c..34a13fe503 100644 --- a/src/google/protobuf/extension_set.cc +++ b/src/google/protobuf/extension_set.cc @@ -825,7 +825,7 @@ MessageLite* ExtensionSet::AddMessage(int number, FieldType type, return reinterpret_cast( extension->ptr.repeated_message_value) - ->AddFromPrototype(&prototype); + ->AddMessage(&prototype); } // Defined in extension_set_heavy.cc. diff --git a/src/google/protobuf/lazy_repeated_field.h b/src/google/protobuf/lazy_repeated_field.h index c166baaed3..ab573e58c0 100644 --- a/src/google/protobuf/lazy_repeated_field.h +++ b/src/google/protobuf/lazy_repeated_field.h @@ -328,7 +328,7 @@ class LazyRepeatedPtrField { const char* ptr2 = ptr; TagType next_tag; do { - MessageLite* submsg = value->AddFromPrototype(prototype); + MessageLite* submsg = value->AddMessage(prototype); // ptr2 points to the start of the element's encoded length. ptr = ctx->ParseMessage(submsg, ptr2); if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr; diff --git a/src/google/protobuf/message.cc b/src/google/protobuf/message.cc index f326125e85..d265e284e1 100644 --- a/src/google/protobuf/message.cc +++ b/src/google/protobuf/message.cc @@ -495,6 +495,28 @@ const internal::RepeatedFieldAccessor* Reflection::RepeatedFieldAccessor( } namespace internal { +template <> +#if defined(_MSC_VER) && (_MSC_VER >= 1800) +// Note: force noinline to workaround MSVC compiler bug with /Zc:inline, issue +// #240 +PROTOBUF_NOINLINE +#endif + Message* + GenericTypeHandler::NewFromPrototype(const Message* prototype, + Arena* arena) { + return prototype->New(arena); +} +template <> +#if defined(_MSC_VER) && (_MSC_VER >= 1800) +// Note: force noinline to workaround MSVC compiler bug with /Zc:inline, issue +// #240 +PROTOBUF_NOINLINE +#endif + Arena* + GenericTypeHandler::GetArena(Message* value) { + return value->GetArena(); +} + template void InternalMetadata::DoClear(); template void InternalMetadata::DoMergeFrom( const UnknownFieldSet& other); diff --git a/src/google/protobuf/message_lite.cc b/src/google/protobuf/message_lite.cc index e7bd959047..456b0b063e 100644 --- a/src/google/protobuf/message_lite.cc +++ b/src/google/protobuf/message_lite.cc @@ -711,6 +711,16 @@ absl::Cord MessageLite::SerializePartialAsCord() const { namespace internal { +MessageLite* NewFromPrototypeHelper(const MessageLite* prototype, + Arena* arena) { + return prototype->New(arena); +} +template <> +void GenericTypeHandler::Merge(const MessageLite& from, + MessageLite* to) { + to->CheckTypeAndMergeFrom(from); +} + // Non-inline variants of std::string specializations for // various InternalMetadata routines. template <> diff --git a/src/google/protobuf/repeated_ptr_field.cc b/src/google/protobuf/repeated_ptr_field.cc index 4c847866cb..5a899210c0 100644 --- a/src/google/protobuf/repeated_ptr_field.cc +++ b/src/google/protobuf/repeated_ptr_field.cc @@ -93,6 +93,14 @@ void RepeatedPtrFieldBase::DestroyProtos() { tagged_rep_or_elem_ = nullptr; } +void* RepeatedPtrFieldBase::AddMessageLite(ElementFactory factory) { + return AddInternal(factory); +} + +void* RepeatedPtrFieldBase::AddString() { + return AddInternal([](Arena* arena) { return NewStringElement(arena); }); +} + void RepeatedPtrFieldBase::CloseGap(int start, int num) { if (using_sso()) { if (start == 0 && num == 1) { @@ -108,6 +116,11 @@ void RepeatedPtrFieldBase::CloseGap(int start, int num) { ExchangeCurrentSize(current_size_ - num); } +MessageLite* RepeatedPtrFieldBase::AddMessage(const MessageLite* prototype) { + return static_cast( + AddInternal([prototype](Arena* a) { return prototype->New(a); })); +} + void InternalOutOfLineDeleteMessageLite(MessageLite* message) { delete message; } @@ -214,6 +227,10 @@ void RepeatedPtrFieldBase::MergeFrom( } } +void* NewStringElement(Arena* arena) { + return Arena::Create(arena); +} + } // namespace internal } // namespace protobuf } // namespace google diff --git a/src/google/protobuf/repeated_ptr_field.h b/src/google/protobuf/repeated_ptr_field.h index 1a0e6126b3..10c57127da 100644 --- a/src/google/protobuf/repeated_ptr_field.h +++ b/src/google/protobuf/repeated_ptr_field.h @@ -108,8 +108,7 @@ class GenericTypeHandler; // using Type = MyType; // using Movable = ...; // -// static ElementFactory GetNewFunc(); -// static ElementFactory GetNewFromPrototypeFunc(const Type* prototype); +// static Type*(*)(Arena*) GetNewFunc(); // static void GetArena(Type* value); // // static Type* New(Arena* arena); @@ -128,6 +127,8 @@ class PROTOBUF_EXPORT RepeatedPtrFieldBase { static constexpr int kSSOCapacity = 1; + using ElementFactory = void* (*)(Arena*); + protected: // We use the same TypeHandler for all Message types to deduplicate generated // code. @@ -191,18 +192,15 @@ class PROTOBUF_EXPORT RepeatedPtrFieldBase { template Value* Add() { - return cast(AddInternal(TypeHandler::GetNewFunc())); - } - - template - Type* AddFromPrototype(const Type* prototype) { - using TypeHandler = GenericTypeHandler; - using H = CommonHandler; - return cast( - AddInternal(H::GetNewFromPrototypeFunc(prototype))); + if (std::is_same, std::string>{}) { + return cast(AddString()); + } + return cast(AddMessageLite(TypeHandler::GetNewFunc())); } - template + template < + typename TypeHandler, + typename std::enable_if::type* = nullptr> inline void Add(Value&& value) { if (current_size_ < allocated_size()) { *cast(element_at(ExchangeCurrentSize(current_size_ + 1))) = @@ -257,6 +255,12 @@ class PROTOBUF_EXPORT RepeatedPtrFieldBase { return *cast(element_at(index)); } + // Creates and adds an element using the given prototype, without introducing + // a link-time dependency on the concrete message type. + // + // Pre-condition: prototype must not be nullptr. + MessageLite* AddMessage(const MessageLite* prototype); + template void Clear() { const int n = current_size_; @@ -721,6 +725,10 @@ class PROTOBUF_EXPORT RepeatedPtrFieldBase { return InternalExtend(n - Capacity()); } + // Internal helpers for Add that keep definition out-of-line. + void* AddMessageLite(ElementFactory factory); + void* AddString(); + // Common implementation used by various Add* methods. `factory` is an object // used to construct a new element unless there are spare cleared elements // ready for reuse. Returns pointer to the new element. @@ -805,32 +813,13 @@ void* RepeatedPtrFieldBase::AddInternal(Factory factory) { PROTOBUF_EXPORT void InternalOutOfLineDeleteMessageLite(MessageLite* message); -// Encapsulates the minimally required subset of T's properties in a -// `RepeatedPtrField` specialization so the type-agnostic -// `RepeatedPtrFieldBase` could do its job without knowing T. -// -// This generic definition is for types derived from `MessageLite`. That is -// statically asserted, but only where a non-conforming type would emit a -// compile-time diagnostic that lacks proper guidance for fixing. Asserting -// at the top level isn't possible, because some template argument types are not -// yet fully defined at the instantiation point. -// -// Explicit specializations are provided for `std::string` and -// `StringPieceField` further below. template class GenericTypeHandler { public: using Type = GenericType; using Movable = IsMovable; - static constexpr auto* GetNewFunc() { return Arena::DefaultConstruct; } - static constexpr auto GetNewFromPrototypeFunc(const Type* prototype) { - static_assert(std::is_base_of::value, ""); - return [prototype](Arena* arena) { - ABSL_DCHECK(prototype != nullptr); - return prototype->New(arena); - }; - } + static constexpr auto GetNewFunc() { return Arena::DefaultConstruct; } static inline Arena* GetArena(Type* value) { return Arena::InternalGetArena(value); } @@ -841,42 +830,76 @@ class GenericTypeHandler { static inline Type* New(Arena* arena, Type&& value) { return Arena::Create(arena, std::move(value)); } - static inline Type* NewFromPrototype(const Type* prototype, + static inline Type* NewFromPrototype(const Type* /*prototype*/, Arena* arena = nullptr) { - static_assert(std::is_base_of::value, ""); - ABSL_DCHECK(prototype != nullptr); - return prototype->New(arena); + return New(arena); } static inline void Delete(Type* value, Arena* arena) { if (arena != nullptr) return; - // Using virtual destructor to reduce generated code size that would have - // happened otherwise due to inlined `~Type()`. - InternalOutOfLineDeleteMessageLite(value); - } - static inline void Clear(Type* value) { - static_assert(std::is_base_of::value, ""); - value->Clear(); - } - static inline void Merge(const Type& from, Type* to) { - static_assert(std::is_base_of::value, ""); - to->CheckTypeAndMergeFrom(from); +#ifdef __cpp_if_constexpr + if constexpr (std::is_base_of::value) { + // Using virtual destructor to reduce generated code size that would have + // happened otherwise due to inlined `~Type()`. + InternalOutOfLineDeleteMessageLite(value); + } else { + delete value; + } +#else + delete value; +#endif } + static inline void Clear(Type* value) { value->Clear(); } + static void Merge(const Type& from, Type* to); static inline size_t SpaceUsedLong(const Type& value) { - static_assert(std::is_base_of::value, ""); return value.SpaceUsedLong(); } }; +// NewFromPrototypeHelper() is not defined inline here, as we will need to do a +// virtual function dispatch anyways to go from Message* to call New/Merge. (The +// additional helper is needed as a workaround for MSVC.) +PROTOBUF_EXPORT MessageLite* NewFromPrototypeHelper( + const MessageLite* prototype, Arena* arena); + +template <> +inline MessageLite* GenericTypeHandler::NewFromPrototype( + const MessageLite* prototype, Arena* arena) { + return NewFromPrototypeHelper(prototype, arena); +} +template <> +inline Arena* GenericTypeHandler::GetArena(MessageLite* value) { + return value->GetArena(); +} + +template +PROTOBUF_NOINLINE inline void GenericTypeHandler::Merge( + const GenericType& from, GenericType* to) { + to->MergeFrom(from); +} +template <> +PROTOBUF_EXPORT void GenericTypeHandler::Merge( + const MessageLite& from, MessageLite* to); + +// Message specialization bodies defined in message.cc. This split is necessary +// to allow proto2-lite (which includes this header) to be independent of +// Message. +template <> +PROTOBUF_EXPORT Message* GenericTypeHandler::NewFromPrototype( + const Message* prototype, Arena* arena); +template <> +PROTOBUF_EXPORT Arena* GenericTypeHandler::GetArena(Message* value); + +PROTOBUF_EXPORT void* NewStringElement(Arena* arena); + template <> class GenericTypeHandler { public: using Type = std::string; using Movable = IsMovable; - static constexpr auto* GetNewFunc() { return Arena::Create; } - static constexpr auto* GetNewFromPrototypeFunc(const Type* prototype) { - return GetNewFunc(); - } + static constexpr auto GetNewFunc() { return NewStringElement; } + static inline Arena* GetArena(Type*) { return nullptr; } + static PROTOBUF_NOINLINE Type* New(Arena* arena) { return Arena::Create(arena); } @@ -891,15 +914,13 @@ class GenericTypeHandler { delete value; } } - static inline Arena* GetArena(Type*) { return nullptr; } static inline void Clear(Type* value) { value->clear(); } static inline void Merge(const Type& from, Type* to) { *to = from; } - static inline size_t SpaceUsedLong(const Type& value) { + static size_t SpaceUsedLong(const Type& value) { return sizeof(value) + StringSpaceUsedExcludingSelfLong(value); } }; - } // namespace internal // RepeatedPtrField is like RepeatedField, but used for repeated strings or @@ -1225,7 +1246,7 @@ class RepeatedPtrField final : private internal::RepeatedPtrFieldBase { void AddAllocatedForParse(Element* p) { - RepeatedPtrFieldBase::AddAllocatedForParse(p); + return RepeatedPtrFieldBase::AddAllocatedForParse(p); } };