Protobuf: Move thread-local global data to globals.cc

third_party/protobuf/patches/0012-extract-globals.patch

 diff -ru --new-file protobuf/src/google/protobuf/arena.cc protobuf2/src/google/protobuf/arena.cc
---- protobuf/src/google/protobuf/arena.cc       2017-03-17 22:40:59.379153132 -0700
-+++ protobuf2/src/google/protobuf/arena.cc      2017-03-17 22:40:52.667151339 -0700
-@@ -39,7 +39,6 @@
+--- 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::thread_cache() {
++Arena::ThreadCache& Arena::cr_thread_cache() {
    static internal::ThreadLocalStorage<ThreadCache>* thread_cache_ =
-@@ -56,7 +55,7 @@
+       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;
-@@ -99,7 +98,7 @@
+@@ -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-17 22:40:59.379153132 -0700
-+++ protobuf2/src/google/protobuf/arena.h       2017-03-17 22:40:52.667151339 -0700
+--- 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,7 +555,6 @@
+@@ -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-17 22:40:59.379153132 -0700
-+++ protobuf2/src/google/protobuf/extension_set.cc      2017-03-17 22:40:52.667151339 -0700
+--- 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_;
 +
@@ skipping 129 matching lines @@
 -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-17 22:40:59.379153132 -0700
-+++ protobuf2/src/google/protobuf/extension_set.h       2017-03-17 22:40:52.675151341 -0700
+--- 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_;
@@ skipping 60 matching lines @@
 @@ -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-17 22:40:59.379153132 -0700
-+++ protobuf2/src/google/protobuf/generated_message_util.cc     2017-03-17 22:40:52.691151345 -0700
+--- 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-17 22:40:59.379153132 -0700
-+++ protobuf2/src/google/protobuf/generated_message_util.h      2017-03-17 22:40:52.655151335 -0700
+--- 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-17 22:40:52.655151335 -0700
-@@ -0,0 +1,113 @@
++++ 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.
@@ skipping 10 matching lines @@
 +// 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>*
@@ skipping 57 matching lines @@
 +  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-17 22:40:59.383153133 -0700
-+++ protobuf2/src/google/protobuf/io/coded_stream.cc    2017-03-17 22:40:52.659151336 -0700
+--- 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-17 22:40:59.383153133 -0700
-+++ protobuf2/src/google/protobuf/io/coded_stream.h     2017-03-17 22:40:52.659151336 -0700
+--- 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-17 22:40:59.383153133 -0700
-+++ protobuf2/src/google/protobuf/stubs/atomicops_internals_x86_gcc.cc  2017-03-17 22:40:52.671151340 -0700
+--- 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 {
  
@@ skipping 45 matching lines @@
 +#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-17 22:40:59.383153133 -0700
-+++ protobuf2/src/google/protobuf/stubs/atomicops_internals_x86_gcc.h   2017-03-17 22:40:52.671151340 -0700
+--- 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")
@@ skipping 46 matching lines @@
 @@ -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-17 22:40:59.383153133 -0700
-+++ protobuf2/src/google/protobuf/stubs/common.cc       2017-03-17 22:40:52.671151340 -0700
+--- 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),
@@ skipping 147 matching lines @@
 -  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-17 22:40:59.383153133 -0700
-+++ protobuf2/src/google/protobuf/stubs/structurally_valid.cc   2017-03-17 22:40:52.675151341 -0700
+--- 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() {
@@ skipping 14 matching lines @@
 @@ -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-17 22:40:59.383153133 -0700
-+++ protobuf2/src/google/protobuf/stubs/strutil.cc      2017-03-17 22:40:52.671151340 -0700
+--- 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