| diff -ru --new-file protobuf/src/google/protobuf/arena.cc protobuf2/src/google/protobuf/arena.cc |
| --- protobuf/src/google/protobuf/arena.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/arena.cc 2017-03-21 21:50:11.671241466 -0700 |
| @@ -39,24 +39,18 @@ |
| namespace protobuf { |
| |
| |
| -google::protobuf::internal::SequenceNumber Arena::lifecycle_id_generator_; |
| #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL) |
| -Arena::ThreadCache& Arena::thread_cache() { |
| +Arena::ThreadCache& Arena::cr_thread_cache() { |
| static internal::ThreadLocalStorage<ThreadCache>* thread_cache_ = |
| new internal::ThreadLocalStorage<ThreadCache>(); |
| return *thread_cache_->Get(); |
| } |
| -#elif defined(PROTOBUF_USE_DLLS) |
| -Arena::ThreadCache& Arena::thread_cache() { |
| - static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_ = { -1, NULL }; |
| - return thread_cache_; |
| -} |
| -#else |
| +#elif !defined(PROTOBUF_USE_DLLS) |
| GOOGLE_THREAD_LOCAL Arena::ThreadCache Arena::thread_cache_ = { -1, NULL }; |
| #endif |
| |
| void Arena::Init() { |
| - lifecycle_id_ = lifecycle_id_generator_.GetNext(); |
| + lifecycle_id_ = internal::cr_lifecycle_id_generator_.GetNext(); |
| blocks_ = 0; |
| hint_ = 0; |
| owns_first_block_ = true; |
| @@ -74,7 +68,7 @@ |
| // Thread which calls Init() owns the first block. This allows the |
| // single-threaded case to allocate on the first block without taking any |
| // locks. |
| - first_block->owner = &thread_cache(); |
| + first_block->owner = &cr_thread_cache(); |
| SetThreadCacheBlock(first_block); |
| AddBlockInternal(first_block); |
| owns_first_block_ = false; |
| @@ -99,7 +93,7 @@ |
| |
| uint64 Arena::Reset() { |
| // Invalidate any ThreadCaches pointing to any blocks we just destroyed. |
| - lifecycle_id_ = lifecycle_id_generator_.GetNext(); |
| + lifecycle_id_ = internal::cr_lifecycle_id_generator_.GetNext(); |
| return ResetInternal(); |
| } |
| |
| @@ -184,18 +178,18 @@ |
| // If this thread already owns a block in this arena then try to use that. |
| // This fast path optimizes the case where multiple threads allocate from the |
| // same arena. |
| - if (thread_cache().last_lifecycle_id_seen == lifecycle_id_ && |
| - thread_cache().last_block_used_ != NULL) { |
| - if (thread_cache().last_block_used_->avail() < n) { |
| + if (cr_thread_cache().last_lifecycle_id_seen == lifecycle_id_ && |
| + cr_thread_cache().last_block_used_ != NULL) { |
| + if (cr_thread_cache().last_block_used_->avail() < n) { |
| return SlowAlloc(n); |
| } |
| - return AllocFromBlock(thread_cache().last_block_used_, n); |
| + return AllocFromBlock(cr_thread_cache().last_block_used_, n); |
| } |
| |
| // Check whether we own the last accessed block on this arena. |
| // This fast path optimizes the case where a single thread uses multiple |
| // arenas. |
| - void* me = &thread_cache(); |
| + void* me = &cr_thread_cache(); |
| Block* b = reinterpret_cast<Block*>(google::protobuf::internal::Acquire_Load(&hint_)); |
| if (!b || b->owner != me || b->avail() < n) { |
| return SlowAlloc(n); |
| @@ -213,7 +207,7 @@ |
| } |
| |
| void* Arena::SlowAlloc(size_t n) { |
| - void* me = &thread_cache(); |
| + void* me = &cr_thread_cache(); |
| Block* b = FindBlock(me); // Find block owned by me. |
| // See if allocation fits in my latest block. |
| if (b != NULL && b->avail() >= n) { |
| @@ -290,7 +284,7 @@ |
| // Thread which calls Reset() owns the first block. This allows the |
| // single-threaded case to allocate on the first block without taking any |
| // locks. |
| - first_block->owner = &thread_cache(); |
| + first_block->owner = &cr_thread_cache(); |
| SetThreadCacheBlock(first_block); |
| AddBlockInternal(first_block); |
| } |
| diff -ru --new-file protobuf/src/google/protobuf/arena.h protobuf2/src/google/protobuf/arena.h |
| --- protobuf/src/google/protobuf/arena.h 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/arena.h 2017-03-21 21:50:11.671241466 -0700 |
| @@ -70,6 +70,9 @@ |
| template<typename Type> |
| class GenericTypeHandler; // repeated_field.h |
| |
| +LIBPROTOBUF_EXPORT extern google::protobuf::internal::SequenceNumber |
| + cr_lifecycle_id_generator_; |
| + |
| // Templated cleanup methods. |
| template<typename T> void arena_destruct_object(void* object) { |
| reinterpret_cast<T*>(object)->~T(); |
| @@ -552,19 +555,20 @@ |
| }; |
| |
| static const size_t kHeaderSize = sizeof(Block); |
| - static google::protobuf::internal::SequenceNumber lifecycle_id_generator_; |
| #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL) |
| // Android ndk does not support GOOGLE_THREAD_LOCAL keyword so we use a custom thread |
| // local storage class we implemented. |
| // iOS also does not support the GOOGLE_THREAD_LOCAL keyword. |
| - static ThreadCache& thread_cache(); |
| + static ThreadCache& cr_thread_cache(); |
| #elif defined(PROTOBUF_USE_DLLS) |
| // Thread local variables cannot be exposed through DLL interface but we can |
| // wrap them in static functions. |
| - static ThreadCache& thread_cache(); |
| + static ThreadCache& cr_thread_cache(); |
| #else |
| static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_; |
| - static ThreadCache& thread_cache() { return thread_cache_; } |
| + static ThreadCache& cr_thread_cache() { |
| + return thread_cache_; |
| + } |
| #endif |
| |
| // SFINAE for skipping addition to delete list for a message type when created |
| @@ -872,8 +876,8 @@ |
| uint64 ResetInternal(); |
| |
| inline void SetThreadCacheBlock(Block* block) { |
| - thread_cache().last_block_used_ = block; |
| - thread_cache().last_lifecycle_id_seen = lifecycle_id_; |
| + cr_thread_cache().last_block_used_ = block; |
| + cr_thread_cache().last_lifecycle_id_seen = lifecycle_id_; |
| } |
| |
| int64 lifecycle_id_; // Unique for each arena. Changes on Reset(). |
| diff -ru --new-file protobuf/src/google/protobuf/extension_set.cc protobuf2/src/google/protobuf/extension_set.cc |
| --- protobuf/src/google/protobuf/extension_set.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/extension_set.cc 2017-03-21 21:50:11.671241466 -0700 |
| @@ -46,6 +46,12 @@ |
| namespace protobuf { |
| namespace internal { |
| |
| +// Registry stuff. |
| +typedef hash_map<pair<const MessageLite*, int>, ExtensionInfo> |
| + ExtensionRegistry; |
| +extern ExtensionRegistry* cr_registry_; |
| +extern ProtobufOnceType cr_registry_init_; |
| + |
| namespace { |
| |
| inline WireFormatLite::FieldType real_type(FieldType type) { |
| @@ -75,19 +81,13 @@ |
| return false; |
| } |
| |
| -// Registry stuff. |
| -typedef hash_map<pair<const MessageLite*, int>, |
| - ExtensionInfo> ExtensionRegistry; |
| -ExtensionRegistry* registry_ = NULL; |
| -GOOGLE_PROTOBUF_DECLARE_ONCE(registry_init_); |
| - |
| void DeleteRegistry() { |
| - delete registry_; |
| - registry_ = NULL; |
| + delete cr_registry_; |
| + cr_registry_ = NULL; |
| } |
| |
| void InitRegistry() { |
| - registry_ = new ExtensionRegistry; |
| + cr_registry_ = new ExtensionRegistry; |
| OnShutdown(&DeleteRegistry); |
| } |
| |
| @@ -95,9 +95,9 @@ |
| // safety. |
| void Register(const MessageLite* containing_type, |
| int number, ExtensionInfo info) { |
| - ::google::protobuf::GoogleOnceInit(®istry_init_, &InitRegistry); |
| + ::google::protobuf::GoogleOnceInit(&cr_registry_init_, &InitRegistry); |
| |
| - if (!InsertIfNotPresent(registry_, std::make_pair(containing_type, number), |
| + if (!InsertIfNotPresent(cr_registry_, std::make_pair(containing_type, number), |
| info)) { |
| GOOGLE_LOG(FATAL) << "Multiple extension registrations for type \"" |
| << containing_type->GetTypeName() |
| @@ -107,9 +107,10 @@ |
| |
| const ExtensionInfo* FindRegisteredExtension( |
| const MessageLite* containing_type, int number) { |
| - return (registry_ == NULL) |
| + return (cr_registry_ == NULL) |
| ? NULL |
| - : FindOrNull(*registry_, std::make_pair(containing_type, number)); |
| + : FindOrNull(*cr_registry_, |
| + std::make_pair(containing_type, number)); |
| } |
| |
| } // namespace |
| @@ -1748,68 +1749,45 @@ |
| // ================================================================== |
| // Default repeated field instances for iterator-compatible accessors |
| |
| -GOOGLE_PROTOBUF_DECLARE_ONCE(repeated_primitive_generic_type_traits_once_init_); |
| -GOOGLE_PROTOBUF_DECLARE_ONCE(repeated_string_type_traits_once_init_); |
| -GOOGLE_PROTOBUF_DECLARE_ONCE(repeated_message_generic_type_traits_once_init_); |
| - |
| void RepeatedPrimitiveGenericTypeTraits::InitializeDefaultRepeatedFields() { |
| - default_repeated_field_int32_ = new RepeatedField<int32>; |
| - default_repeated_field_int64_ = new RepeatedField<int64>; |
| - default_repeated_field_uint32_ = new RepeatedField<uint32>; |
| - default_repeated_field_uint64_ = new RepeatedField<uint64>; |
| - default_repeated_field_double_ = new RepeatedField<double>; |
| - default_repeated_field_float_ = new RepeatedField<float>; |
| - default_repeated_field_bool_ = new RepeatedField<bool>; |
| + cr_default_repeated_field_int32_ = new RepeatedField<int32>; |
| + cr_default_repeated_field_int64_ = new RepeatedField<int64>; |
| + cr_default_repeated_field_uint32_ = new RepeatedField<uint32>; |
| + cr_default_repeated_field_uint64_ = new RepeatedField<uint64>; |
| + cr_default_repeated_field_double_ = new RepeatedField<double>; |
| + cr_default_repeated_field_float_ = new RepeatedField<float>; |
| + cr_default_repeated_field_bool_ = new RepeatedField<bool>; |
| OnShutdown(&DestroyDefaultRepeatedFields); |
| } |
| |
| void RepeatedPrimitiveGenericTypeTraits::DestroyDefaultRepeatedFields() { |
| - delete default_repeated_field_int32_; |
| - delete default_repeated_field_int64_; |
| - delete default_repeated_field_uint32_; |
| - delete default_repeated_field_uint64_; |
| - delete default_repeated_field_double_; |
| - delete default_repeated_field_float_; |
| - delete default_repeated_field_bool_; |
| + delete cr_default_repeated_field_int32_; |
| + delete cr_default_repeated_field_int64_; |
| + delete cr_default_repeated_field_uint32_; |
| + delete cr_default_repeated_field_uint64_; |
| + delete cr_default_repeated_field_double_; |
| + delete cr_default_repeated_field_float_; |
| + delete cr_default_repeated_field_bool_; |
| } |
| |
| void RepeatedStringTypeTraits::InitializeDefaultRepeatedFields() { |
| - default_repeated_field_ = new RepeatedFieldType; |
| + cr_default_repeated_field_ = new RepeatedFieldType; |
| OnShutdown(&DestroyDefaultRepeatedFields); |
| } |
| |
| void RepeatedStringTypeTraits::DestroyDefaultRepeatedFields() { |
| - delete default_repeated_field_; |
| + delete cr_default_repeated_field_; |
| } |
| |
| void RepeatedMessageGenericTypeTraits::InitializeDefaultRepeatedFields() { |
| - default_repeated_field_ = new RepeatedFieldType; |
| + cr_default_repeated_field_ = new RepeatedFieldType; |
| OnShutdown(&DestroyDefaultRepeatedFields); |
| } |
| |
| void RepeatedMessageGenericTypeTraits::DestroyDefaultRepeatedFields() { |
| - delete default_repeated_field_; |
| + delete cr_default_repeated_field_; |
| } |
| |
| -const RepeatedField<int32>* |
| -RepeatedPrimitiveGenericTypeTraits::default_repeated_field_int32_ = NULL; |
| -const RepeatedField<int64>* |
| -RepeatedPrimitiveGenericTypeTraits::default_repeated_field_int64_ = NULL; |
| -const RepeatedField<uint32>* |
| -RepeatedPrimitiveGenericTypeTraits::default_repeated_field_uint32_ = NULL; |
| -const RepeatedField<uint64>* |
| -RepeatedPrimitiveGenericTypeTraits::default_repeated_field_uint64_ = NULL; |
| -const RepeatedField<double>* |
| -RepeatedPrimitiveGenericTypeTraits::default_repeated_field_double_ = NULL; |
| -const RepeatedField<float>* |
| -RepeatedPrimitiveGenericTypeTraits::default_repeated_field_float_ = NULL; |
| -const RepeatedField<bool>* |
| -RepeatedPrimitiveGenericTypeTraits::default_repeated_field_bool_ = NULL; |
| -const RepeatedStringTypeTraits::RepeatedFieldType* |
| -RepeatedStringTypeTraits::default_repeated_field_ = NULL; |
| -const RepeatedMessageGenericTypeTraits::RepeatedFieldType* |
| -RepeatedMessageGenericTypeTraits::default_repeated_field_ = NULL; |
| - |
| } // namespace internal |
| } // namespace protobuf |
| } // namespace google |
| diff -ru --new-file protobuf/src/google/protobuf/extension_set.h protobuf2/src/google/protobuf/extension_set.h |
| --- protobuf/src/google/protobuf/extension_set.h 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/extension_set.h 2017-03-21 21:50:11.679241474 -0700 |
| @@ -731,13 +731,13 @@ |
| template<typename Type> friend class RepeatedPrimitiveTypeTraits; |
| static void InitializeDefaultRepeatedFields(); |
| static void DestroyDefaultRepeatedFields(); |
| - static const RepeatedField<int32>* default_repeated_field_int32_; |
| - static const RepeatedField<int64>* default_repeated_field_int64_; |
| - static const RepeatedField<uint32>* default_repeated_field_uint32_; |
| - static const RepeatedField<uint64>* default_repeated_field_uint64_; |
| - static const RepeatedField<double>* default_repeated_field_double_; |
| - static const RepeatedField<float>* default_repeated_field_float_; |
| - static const RepeatedField<bool>* default_repeated_field_bool_; |
| + static const RepeatedField<int32>* cr_default_repeated_field_int32_; |
| + static const RepeatedField<int64>* cr_default_repeated_field_int64_; |
| + static const RepeatedField<uint32>* cr_default_repeated_field_uint32_; |
| + static const RepeatedField<uint64>* cr_default_repeated_field_uint64_; |
| + static const RepeatedField<double>* cr_default_repeated_field_double_; |
| + static const RepeatedField<float>* cr_default_repeated_field_float_; |
| + static const RepeatedField<bool>* cr_default_repeated_field_bool_; |
| }; |
| |
| #define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD) \ |
| @@ -769,7 +769,7 @@ |
| &repeated_primitive_generic_type_traits_once_init_, \ |
| &RepeatedPrimitiveGenericTypeTraits::InitializeDefaultRepeatedFields); \ |
| return RepeatedPrimitiveGenericTypeTraits:: \ |
| - default_repeated_field_##TYPE##_; \ |
| + cr_default_repeated_field_##TYPE##_; \ |
| } \ |
| template<> inline const RepeatedField<TYPE>& \ |
| RepeatedPrimitiveTypeTraits<TYPE>::GetRepeated(int number, \ |
| @@ -821,7 +821,8 @@ |
| } |
| }; |
| |
| -LIBPROTOBUF_EXPORT extern ProtobufOnceType repeated_string_type_traits_once_init_; |
| +LIBPROTOBUF_EXPORT extern ProtobufOnceType |
| + cr_repeated_string_type_traits_once_init_; |
| |
| class LIBPROTOBUF_EXPORT RepeatedStringTypeTraits { |
| public: |
| @@ -866,15 +867,16 @@ |
| } |
| |
| static const RepeatedFieldType* GetDefaultRepeatedField() { |
| - ::google::protobuf::GoogleOnceInit(&repeated_string_type_traits_once_init_, |
| - &InitializeDefaultRepeatedFields); |
| - return default_repeated_field_; |
| + ::google::protobuf::GoogleOnceInit( |
| + &cr_repeated_string_type_traits_once_init_, |
| + &InitializeDefaultRepeatedFields); |
| + return cr_default_repeated_field_; |
| } |
| |
| private: |
| static void InitializeDefaultRepeatedFields(); |
| static void DestroyDefaultRepeatedFields(); |
| - static const RepeatedFieldType *default_repeated_field_; |
| + static const RepeatedFieldType* cr_default_repeated_field_; |
| }; |
| |
| // ------------------------------------------------------------------- |
| @@ -1043,7 +1045,7 @@ |
| template<typename Type> friend class RepeatedMessageTypeTraits; |
| static void InitializeDefaultRepeatedFields(); |
| static void DestroyDefaultRepeatedFields(); |
| - static const RepeatedFieldType* default_repeated_field_; |
| + static const RepeatedFieldType* cr_default_repeated_field_; |
| }; |
| |
| template<typename Type> inline |
| @@ -1053,7 +1055,7 @@ |
| &repeated_message_generic_type_traits_once_init_, |
| &RepeatedMessageGenericTypeTraits::InitializeDefaultRepeatedFields); |
| return reinterpret_cast<const RepeatedFieldType*>( |
| - RepeatedMessageGenericTypeTraits::default_repeated_field_); |
| + RepeatedMessageGenericTypeTraits::cr_default_repeated_field_); |
| } |
| |
| // ------------------------------------------------------------------- |
| diff -ru --new-file protobuf/src/google/protobuf/generated_message_util.cc protobuf2/src/google/protobuf/generated_message_util.cc |
| --- protobuf/src/google/protobuf/generated_message_util.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/generated_message_util.cc 2017-03-21 21:50:11.695241487 -0700 |
| @@ -48,20 +48,18 @@ |
| return std::numeric_limits<double>::quiet_NaN(); |
| } |
| |
| -const ::std::string* empty_string_; |
| -GOOGLE_PROTOBUF_DECLARE_ONCE(empty_string_once_init_); |
| - |
| void DeleteEmptyString() { |
| - delete empty_string_; |
| + delete cr_empty_string_; |
| } |
| |
| void InitEmptyString() { |
| - empty_string_ = new string; |
| + cr_empty_string_ = new string; |
| OnShutdown(&DeleteEmptyString); |
| } |
| |
| const ::std::string& GetEmptyString() { |
| - ::google::protobuf::GoogleOnceInit(&empty_string_once_init_, &InitEmptyString); |
| + ::google::protobuf::GoogleOnceInit(&cr_empty_string_once_init_, |
| + &InitEmptyString); |
| return GetEmptyStringAlreadyInited(); |
| } |
| |
| diff -ru --new-file protobuf/src/google/protobuf/generated_message_util.h protobuf2/src/google/protobuf/generated_message_util.h |
| --- protobuf/src/google/protobuf/generated_message_util.h 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/generated_message_util.h 2017-03-21 21:50:11.659241456 -0700 |
| @@ -77,14 +77,14 @@ |
| |
| // Default empty string object. Don't use the pointer directly. Instead, call |
| // GetEmptyString() to get the reference. |
| -LIBPROTOBUF_EXPORT extern const ::std::string* empty_string_; |
| -LIBPROTOBUF_EXPORT extern ProtobufOnceType empty_string_once_init_; |
| +LIBPROTOBUF_EXPORT extern const ::std::string* cr_empty_string_; |
| +LIBPROTOBUF_EXPORT extern ProtobufOnceType cr_empty_string_once_init_; |
| LIBPROTOBUF_EXPORT void InitEmptyString(); |
| |
| |
| LIBPROTOBUF_EXPORT inline const ::std::string& GetEmptyStringAlreadyInited() { |
| - assert(empty_string_ != NULL); |
| - return *empty_string_; |
| + assert(cr_empty_string_ != NULL); |
| + return *cr_empty_string_; |
| } |
| |
| LIBPROTOBUF_EXPORT const ::std::string& GetEmptyString(); |
| diff -ru --new-file protobuf/src/google/protobuf/globals.cc protobuf2/src/google/protobuf/globals.cc |
| --- protobuf/src/google/protobuf/globals.cc 1969-12-31 16:00:00.000000000 -0800 |
| +++ protobuf2/src/google/protobuf/globals.cc 2017-03-21 21:50:11.659241456 -0700 |
| @@ -0,0 +1,122 @@ |
| +// Protocol Buffers - Google's data interchange format |
| +// Copyright 2017 Google Inc. All rights reserved. |
| +// https://developers.google.com/protocol-buffers/ |
| +// |
| +// Redistribution and use in source and binary forms, with or without |
| +// modification, are permitted provided that the following conditions are |
| +// met: |
| +// |
| +// * Redistributions of source code must retain the above copyright |
| +// notice, this list of conditions and the following disclaimer. |
| +// * Redistributions in binary form must reproduce the above |
| +// copyright notice, this list of conditions and the following disclaimer |
| +// in the documentation and/or other materials provided with the |
| +// distribution. |
| +// * Neither the name of Google Inc. nor the names of its |
| +// contributors may be used to endorse or promote products derived from |
| +// this software without specific prior written permission. |
| +// |
| +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| + |
| +#include <google/protobuf/arena.h> |
| +#include <google/protobuf/extension_set.h> |
| +#include <google/protobuf/generated_message_util.h> |
| +#include <google/protobuf/stubs/atomicops.h> |
| +#include <google/protobuf/stubs/hash.h> |
| + |
| +namespace google { |
| +namespace protobuf { |
| + |
| +#if !defined(GOOGLE_PROTOBUF_NO_THREADLOCAL) && defined(PROTOBUF_USE_DLLS) |
| +Arena::ThreadCache& Arena::cr_thread_cache() { |
| + static GOOGLE_THREAD_LOCAL ThreadCache cr_thread_cache_ = {-1, NULL}; |
| + return cr_thread_cache_; |
| +} |
| +#endif |
| + |
| +namespace internal { |
| + |
| +SequenceNumber cr_lifecycle_id_generator_; |
| + |
| +const ::std::string* cr_empty_string_; |
| +GOOGLE_PROTOBUF_DECLARE_ONCE(cr_empty_string_once_init_); |
| + |
| +const RepeatedField<int32>* |
| + RepeatedPrimitiveGenericTypeTraits::cr_default_repeated_field_int32_ = NULL; |
| +const RepeatedField<int64>* |
| + RepeatedPrimitiveGenericTypeTraits::cr_default_repeated_field_int64_ = NULL; |
| +const RepeatedField<uint32>* |
| + RepeatedPrimitiveGenericTypeTraits::cr_default_repeated_field_uint32_ = |
| + NULL; |
| +const RepeatedField<uint64>* |
| + RepeatedPrimitiveGenericTypeTraits::cr_default_repeated_field_uint64_ = |
| + NULL; |
| +const RepeatedField<double>* |
| + RepeatedPrimitiveGenericTypeTraits::cr_default_repeated_field_double_ = |
| + NULL; |
| +const RepeatedField<float>* |
| + RepeatedPrimitiveGenericTypeTraits::cr_default_repeated_field_float_ = NULL; |
| +const RepeatedField<bool>* |
| + RepeatedPrimitiveGenericTypeTraits::cr_default_repeated_field_bool_ = NULL; |
| +const RepeatedStringTypeTraits::RepeatedFieldType* |
| + RepeatedStringTypeTraits::cr_default_repeated_field_ = NULL; |
| +const RepeatedMessageGenericTypeTraits::RepeatedFieldType* |
| + RepeatedMessageGenericTypeTraits::cr_default_repeated_field_ = NULL; |
| + |
| +LIBPROTOBUF_EXPORT vector<void (*)()>* cr_shutdown_functions = NULL; |
| +LIBPROTOBUF_EXPORT Mutex* cr_shutdown_functions_mutex = NULL; |
| +LIBPROTOBUF_EXPORT GOOGLE_PROTOBUF_DECLARE_ONCE(cr_shutdown_functions_init); |
| + |
| +LIBPROTOBUF_EXPORT LogHandler* cr_log_handler_ = NULL; |
| +LIBPROTOBUF_EXPORT int cr_log_silencer_count_ = 0; |
| + |
| +LIBPROTOBUF_EXPORT Mutex* cr_log_silencer_count_mutex_ = NULL; |
| +LIBPROTOBUF_EXPORT GOOGLE_PROTOBUF_DECLARE_ONCE(cr_log_silencer_count_init_); |
| + |
| +GOOGLE_PROTOBUF_DECLARE_ONCE( |
| + cr_repeated_primitive_generic_type_traits_once_init_); |
| +GOOGLE_PROTOBUF_DECLARE_ONCE(cr_repeated_string_type_traits_once_init_); |
| +GOOGLE_PROTOBUF_DECLARE_ONCE( |
| + cr_repeated_message_generic_type_traits_once_init_); |
| + |
| +LIBPROTOBUF_EXPORT hash_map<pair<const MessageLite*, int>, ExtensionInfo>* |
| + cr_registry_ = NULL; |
| +LIBPROTOBUF_EXPORT GOOGLE_PROTOBUF_DECLARE_ONCE(cr_registry_init_); |
| + |
| +LIBPROTOBUF_EXPORT bool cr_module_initialized_ = false; |
| +struct InitDetector { |
| + InitDetector() { cr_module_initialized_ = true; } |
| +}; |
| +InitDetector cr_init_detector; |
| + |
| +#ifdef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_ |
| +// Set the flags so that code will run correctly and conservatively, so even |
| +// if we haven't been initialized yet, we're probably single threaded, and our |
| +// default values should hopefully be pretty safe. |
| +LIBPROTOBUF_EXPORT struct AtomicOps_x86CPUFeatureStruct |
| + cr_AtomicOps_Internalx86CPUFeatures = { |
| + false, // bug can't exist before process spawns multiple threads |
| + false, // no SSE2 |
| +}; |
| + |
| +class AtomicOpsx86Initializer { |
| + public: |
| + AtomicOpsx86Initializer() { AtomicOps_Internalx86CPUFeaturesInit(); } |
| +}; |
| + |
| +AtomicOpsx86Initializer cr_g_initer; |
| +#endif |
| + |
| +} // namespace internal |
| +} // namespace protobuf |
| +} // namespace google |
| diff -ru --new-file protobuf/src/google/protobuf/io/coded_stream.cc protobuf2/src/google/protobuf/io/coded_stream.cc |
| --- protobuf/src/google/protobuf/io/coded_stream.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/io/coded_stream.cc 2017-03-21 21:50:11.663241460 -0700 |
| @@ -83,7 +83,7 @@ |
| } |
| |
| // Static. |
| -int CodedInputStream::default_recursion_limit_ = 100; |
| +int const CodedInputStream::default_recursion_limit_ = 100; |
| |
| |
| void CodedOutputStream::EnableAliasing(bool enabled) { |
| diff -ru --new-file protobuf/src/google/protobuf/io/coded_stream.h protobuf2/src/google/protobuf/io/coded_stream.h |
| --- protobuf/src/google/protobuf/io/coded_stream.h 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/io/coded_stream.h 2017-03-21 21:50:11.663241460 -0700 |
| @@ -613,7 +613,7 @@ |
| |
| static const int kDefaultTotalBytesWarningThreshold = 32 << 20; // 32MB |
| |
| - static int default_recursion_limit_; // 100 by default. |
| + static const int default_recursion_limit_; // 100 by default. |
| }; |
| |
| // Class which encodes and writes binary data which is composed of varint- |
| diff -ru --new-file protobuf/src/google/protobuf/stubs/atomicops_internals_x86_gcc.cc protobuf2/src/google/protobuf/stubs/atomicops_internals_x86_gcc.cc |
| --- protobuf/src/google/protobuf/stubs/atomicops_internals_x86_gcc.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/stubs/atomicops_internals_x86_gcc.cc 2017-03-21 21:50:11.675241470 -0700 |
| @@ -58,23 +58,13 @@ |
| : "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp)) |
| #endif |
| |
| -#if defined(cpuid) // initialize the struct only on x86 |
| - |
| namespace google { |
| namespace protobuf { |
| namespace internal { |
| |
| -// Set the flags so that code will run correctly and conservatively, so even |
| -// if we haven't been initialized yet, we're probably single threaded, and our |
| -// default values should hopefully be pretty safe. |
| -struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures = { |
| - false, // bug can't exist before process spawns multiple threads |
| - false, // no SSE2 |
| -}; |
| - |
| -namespace { |
| +#if defined(cpuid) // initialize the struct only on x86 |
| |
| -// Initialize the AtomicOps_Internalx86CPUFeatures struct. |
| +// Initialize the cr_AtomicOps_Internalx86CPUFeatures struct. |
| void AtomicOps_Internalx86CPUFeaturesInit() { |
| uint32_t eax; |
| uint32_t ebx; |
| @@ -107,31 +97,20 @@ |
| if (strcmp(vendor, "AuthenticAMD") == 0 && // AMD |
| family == 15 && |
| 32 <= model && model <= 63) { |
| - AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug = true; |
| + cr_AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug = true; |
| } else { |
| - AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug = false; |
| + cr_AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug = false; |
| } |
| |
| // edx bit 26 is SSE2 which we use to tell use whether we can use mfence |
| - AtomicOps_Internalx86CPUFeatures.has_sse2 = ((edx >> 26) & 1); |
| + cr_AtomicOps_Internalx86CPUFeatures.has_sse2 = ((edx >> 26) & 1); |
| } |
| - |
| -class AtomicOpsx86Initializer { |
| - public: |
| - AtomicOpsx86Initializer() { |
| - AtomicOps_Internalx86CPUFeaturesInit(); |
| - } |
| -}; |
| - |
| -// A global to get use initialized on startup via static initialization :/ |
| -AtomicOpsx86Initializer g_initer; |
| - |
| -} // namespace |
| +#else |
| +void AtomicOps_Internalx86CPUFeaturesInit() {} |
| +#endif // __i386__ |
| |
| } // namespace internal |
| } // namespace protobuf |
| } // namespace google |
| |
| -#endif // __i386__ |
| - |
| #endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_ |
| diff -ru --new-file protobuf/src/google/protobuf/stubs/atomicops_internals_x86_gcc.h protobuf2/src/google/protobuf/stubs/atomicops_internals_x86_gcc.h |
| --- protobuf/src/google/protobuf/stubs/atomicops_internals_x86_gcc.h 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/stubs/atomicops_internals_x86_gcc.h 2017-03-21 21:50:11.675241470 -0700 |
| @@ -46,7 +46,9 @@ |
| // after acquire compare-and-swap. |
| bool has_sse2; // Processor has SSE2. |
| }; |
| -extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures; |
| +extern struct AtomicOps_x86CPUFeatureStruct cr_AtomicOps_Internalx86CPUFeatures; |
| + |
| +void AtomicOps_Internalx86CPUFeaturesInit(); |
| |
| #define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory") |
| |
| @@ -89,7 +91,7 @@ |
| : "+r" (temp), "+m" (*ptr) |
| : : "memory"); |
| // temp now holds the old value of *ptr |
| - if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| + if (cr_AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| __asm__ __volatile__("lfence" : : : "memory"); |
| } |
| return temp + increment; |
| @@ -99,7 +101,7 @@ |
| Atomic32 old_value, |
| Atomic32 new_value) { |
| Atomic32 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
| - if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| + if (cr_AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| __asm__ __volatile__("lfence" : : : "memory"); |
| } |
| return x; |
| @@ -131,7 +133,7 @@ |
| #else |
| |
| inline void MemoryBarrier() { |
| - if (AtomicOps_Internalx86CPUFeatures.has_sse2) { |
| + if (cr_AtomicOps_Internalx86CPUFeatures.has_sse2) { |
| __asm__ __volatile__("mfence" : : : "memory"); |
| } else { // mfence is faster but not present on PIII |
| Atomic32 x = 0; |
| @@ -140,7 +142,7 @@ |
| } |
| |
| inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
| - if (AtomicOps_Internalx86CPUFeatures.has_sse2) { |
| + if (cr_AtomicOps_Internalx86CPUFeatures.has_sse2) { |
| *ptr = value; |
| __asm__ __volatile__("mfence" : : : "memory"); |
| } else { |
| @@ -213,7 +215,7 @@ |
| : "+r" (temp), "+m" (*ptr) |
| : : "memory"); |
| // temp now contains the previous value of *ptr |
| - if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| + if (cr_AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| __asm__ __volatile__("lfence" : : : "memory"); |
| } |
| return temp + increment; |
| @@ -270,7 +272,7 @@ |
| Atomic64 old_value, |
| Atomic64 new_value) { |
| Atomic64 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
| - if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| + if (cr_AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
| __asm__ __volatile__("lfence" : : : "memory"); |
| } |
| return x; |
| diff -ru --new-file protobuf/src/google/protobuf/stubs/common.cc protobuf2/src/google/protobuf/stubs/common.cc |
| --- protobuf/src/google/protobuf/stubs/common.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/stubs/common.cc 2017-03-21 21:50:11.675241470 -0700 |
| @@ -116,7 +116,8 @@ |
| if (level < GOOGLE_PROTOBUF_MIN_LOG_LEVEL) { |
| return; |
| } |
| - static const char* level_names[] = {"INFO", "WARNING", "ERROR", "FATAL"}; |
| + static const char* const level_names[] = {"INFO", "WARNING", "ERROR", |
| + "FATAL"}; |
| |
| static const int android_log_levels[] = { |
| ANDROID_LOG_INFO, // LOG(INFO), |
| @@ -148,7 +149,8 @@ |
| #else |
| void DefaultLogHandler(LogLevel level, const char* filename, int line, |
| const string& message) { |
| - static const char* level_names[] = { "INFO", "WARNING", "ERROR", "FATAL" }; |
| + static const char* const level_names[] = {"INFO", "WARNING", "ERROR", |
| + "FATAL"}; |
| |
| // We use fprintf() instead of cerr because we want this to work at static |
| // initialization time. |
| @@ -163,22 +165,22 @@ |
| // Nothing. |
| } |
| |
| -static LogHandler* log_handler_ = &DefaultLogHandler; |
| -static int log_silencer_count_ = 0; |
| +extern LogHandler* cr_log_handler_; |
| +extern int cr_log_silencer_count_; |
| |
| -static Mutex* log_silencer_count_mutex_ = NULL; |
| -GOOGLE_PROTOBUF_DECLARE_ONCE(log_silencer_count_init_); |
| +extern Mutex* cr_log_silencer_count_mutex_; |
| +extern ProtobufOnceType cr_log_silencer_count_init_; |
| |
| void DeleteLogSilencerCount() { |
| - delete log_silencer_count_mutex_; |
| - log_silencer_count_mutex_ = NULL; |
| + delete cr_log_silencer_count_mutex_; |
| + cr_log_silencer_count_mutex_ = NULL; |
| } |
| void InitLogSilencerCount() { |
| - log_silencer_count_mutex_ = new Mutex; |
| + cr_log_silencer_count_mutex_ = new Mutex; |
| OnShutdown(&DeleteLogSilencerCount); |
| } |
| void InitLogSilencerCountOnce() { |
| - GoogleOnceInit(&log_silencer_count_init_, &InitLogSilencerCount); |
| + GoogleOnceInit(&cr_log_silencer_count_init_, &InitLogSilencerCount); |
| } |
| |
| LogMessage& LogMessage::operator<<(const string& value) { |
| @@ -246,12 +248,13 @@ |
| |
| if (level_ != LOGLEVEL_FATAL) { |
| InitLogSilencerCountOnce(); |
| - MutexLock lock(log_silencer_count_mutex_); |
| - suppress = log_silencer_count_ > 0; |
| + MutexLock lock(cr_log_silencer_count_mutex_); |
| + suppress = cr_log_silencer_count_ > 0; |
| } |
| |
| if (!suppress) { |
| - log_handler_(level_, filename_, line_, message_); |
| + (cr_log_handler_ ? cr_log_handler_ : DefaultLogHandler)(level_, filename_, |
| + line_, message_); |
| } |
| |
| if (level_ == LOGLEVEL_FATAL) { |
| @@ -270,28 +273,29 @@ |
| } // namespace internal |
| |
| LogHandler* SetLogHandler(LogHandler* new_func) { |
| - LogHandler* old = internal::log_handler_; |
| + LogHandler* old = internal::cr_log_handler_ ? internal::cr_log_handler_ |
| + : internal::DefaultLogHandler; |
| if (old == &internal::NullLogHandler) { |
| old = NULL; |
| } |
| if (new_func == NULL) { |
| - internal::log_handler_ = &internal::NullLogHandler; |
| + internal::cr_log_handler_ = &internal::NullLogHandler; |
| } else { |
| - internal::log_handler_ = new_func; |
| + internal::cr_log_handler_ = new_func; |
| } |
| return old; |
| } |
| |
| LogSilencer::LogSilencer() { |
| internal::InitLogSilencerCountOnce(); |
| - MutexLock lock(internal::log_silencer_count_mutex_); |
| - ++internal::log_silencer_count_; |
| + MutexLock lock(internal::cr_log_silencer_count_mutex_); |
| + ++internal::cr_log_silencer_count_; |
| }; |
| |
| LogSilencer::~LogSilencer() { |
| internal::InitLogSilencerCountOnce(); |
| - MutexLock lock(internal::log_silencer_count_mutex_); |
| - --internal::log_silencer_count_; |
| + MutexLock lock(internal::cr_log_silencer_count_mutex_); |
| + --internal::cr_log_silencer_count_; |
| }; |
| |
| // =================================================================== |
| @@ -407,23 +411,23 @@ |
| namespace internal { |
| |
| typedef void OnShutdownFunc(); |
| -vector<void (*)()>* shutdown_functions = NULL; |
| -Mutex* shutdown_functions_mutex = NULL; |
| -GOOGLE_PROTOBUF_DECLARE_ONCE(shutdown_functions_init); |
| +extern vector<void (*)()>* cr_shutdown_functions; |
| +extern Mutex* cr_shutdown_functions_mutex; |
| +extern ProtobufOnceType cr_shutdown_functions_init; |
| |
| void InitShutdownFunctions() { |
| - shutdown_functions = new vector<void (*)()>; |
| - shutdown_functions_mutex = new Mutex; |
| + cr_shutdown_functions = new vector<void (*)()>; |
| + cr_shutdown_functions_mutex = new Mutex; |
| } |
| |
| inline void InitShutdownFunctionsOnce() { |
| - GoogleOnceInit(&shutdown_functions_init, &InitShutdownFunctions); |
| + GoogleOnceInit(&cr_shutdown_functions_init, &InitShutdownFunctions); |
| } |
| |
| void OnShutdown(void (*func)()) { |
| InitShutdownFunctionsOnce(); |
| - MutexLock lock(shutdown_functions_mutex); |
| - shutdown_functions->push_back(func); |
| + MutexLock lock(cr_shutdown_functions_mutex); |
| + cr_shutdown_functions->push_back(func); |
| } |
| |
| } // namespace internal |
| @@ -431,20 +435,20 @@ |
| void ShutdownProtobufLibrary() { |
| internal::InitShutdownFunctionsOnce(); |
| |
| - // We don't need to lock shutdown_functions_mutex because it's up to the |
| + // We don't need to lock cr_shutdown_functions_mutex because it's up to the |
| // caller to make sure that no one is using the library before this is |
| // called. |
| |
| // Make it safe to call this multiple times. |
| - if (internal::shutdown_functions == NULL) return; |
| + if (internal::cr_shutdown_functions == NULL) return; |
| |
| - for (int i = 0; i < internal::shutdown_functions->size(); i++) { |
| - internal::shutdown_functions->at(i)(); |
| + for (int i = 0; i < internal::cr_shutdown_functions->size(); i++) { |
| + internal::cr_shutdown_functions->at(i)(); |
| } |
| - delete internal::shutdown_functions; |
| - internal::shutdown_functions = NULL; |
| - delete internal::shutdown_functions_mutex; |
| - internal::shutdown_functions_mutex = NULL; |
| + delete internal::cr_shutdown_functions; |
| + internal::cr_shutdown_functions = NULL; |
| + delete internal::cr_shutdown_functions_mutex; |
| + internal::cr_shutdown_functions_mutex = NULL; |
| } |
| |
| #if PROTOBUF_USE_EXCEPTIONS |
| diff -ru --new-file protobuf/src/google/protobuf/stubs/structurally_valid.cc protobuf2/src/google/protobuf/stubs/structurally_valid.cc |
| --- protobuf/src/google/protobuf/stubs/structurally_valid.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/stubs/structurally_valid.cc 2017-03-21 21:50:11.679241474 -0700 |
| @@ -511,21 +511,10 @@ |
| // UTF-8 strings. Since UTF-8 validation is only used for debugging |
| // anyway, we simply always return success if initialization hasn't |
| // occurred yet. |
| -namespace { |
| - |
| -bool module_initialized_ = false; |
| - |
| -struct InitDetector { |
| - InitDetector() { |
| - module_initialized_ = true; |
| - } |
| -}; |
| -InitDetector init_detector; |
| - |
| -} // namespace |
| +extern bool cr_module_initialized_; |
| |
| bool IsStructurallyValidUTF8(const char* buf, int len) { |
| - if (!module_initialized_) return true; |
| + if (!cr_module_initialized_) return true; |
| |
| int bytes_consumed = 0; |
| UTF8GenericScanFastAscii(&utf8acceptnonsurrogates_obj, |
| @@ -534,7 +523,7 @@ |
| } |
| |
| int UTF8SpnStructurallyValid(const StringPiece& str) { |
| - if (!module_initialized_) return str.size(); |
| + if (!cr_module_initialized_) return str.size(); |
| |
| int bytes_consumed = 0; |
| UTF8GenericScanFastAscii(&utf8acceptnonsurrogates_obj, |
| diff -ru --new-file protobuf/src/google/protobuf/stubs/strutil.cc protobuf2/src/google/protobuf/stubs/strutil.cc |
| --- protobuf/src/google/protobuf/stubs/strutil.cc 2017-03-21 21:50:28.399255503 -0700 |
| +++ protobuf2/src/google/protobuf/stubs/strutil.cc 2017-03-21 21:50:11.675241470 -0700 |
| @@ -528,7 +528,7 @@ |
| // Assumes that non-printable characters are escaped using octal sequences, and |
| // that UTF-8 bytes are not handled specially. |
| static inline size_t CEscapedLength(StringPiece src) { |
| - static char c_escaped_len[256] = { |
| + static const char c_escaped_len[256] = { |
| 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 4, 4, 2, 4, 4, // \t, \n, \r |
| 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, |
| 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // ", ' |
| @@ -891,7 +891,7 @@ |
| char *FastHexToBuffer(int i, char* buffer) { |
| GOOGLE_CHECK(i >= 0) << "FastHexToBuffer() wants non-negative integers, not " << i; |
| |
| - static const char *hexdigits = "0123456789abcdef"; |
| + static const char hexdigits[] = "0123456789abcdef"; |
| char *p = buffer + 21; |
| *p-- = '\0'; |
| do { |
| @@ -902,7 +902,7 @@ |
| } |
| |
| char *InternalFastHexToBuffer(uint64 value, char* buffer, int num_byte) { |
| - static const char *hexdigits = "0123456789abcdef"; |
| + static const char hexdigits[] = "0123456789abcdef"; |
| buffer[num_byte] = '\0'; |
| for (int i = num_byte - 1; i >= 0; i--) { |
| #ifdef _M_X64 |