third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/arena.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 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 12 matching lines @@
 // 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 <algorithm>
+#include <limits>
+
 
 #ifdef ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
-#endif
+#endif  // ADDRESS_SANITIZER
 
 namespace google {
 namespace protobuf {
 
 
 google::protobuf::internal::SequenceNumber Arena::lifecycle_id_generator_;
 #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
 Arena::ThreadCache& Arena::thread_cache() {
   static internal::ThreadLocalStorage<ThreadCache>* thread_cache_ =
       new internal::ThreadLocalStorage<ThreadCache>();
@@ skipping 71 matching lines @@
 Arena::Block* Arena::NewBlock(void* me, Block* my_last_block, size_t n,
                               size_t start_block_size, size_t max_block_size) {
   size_t size;
   if (my_last_block != NULL) {
     // Double the current block size, up to a limit.
     size = 2 * (my_last_block->size);
     if (size > max_block_size) size = max_block_size;
   } else {
     size = start_block_size;
   }
-  if (n > size - kHeaderSize) {
-    // TODO(sanjay): Check if n + kHeaderSize would overflow
-    size = kHeaderSize + n;
-  }
+  // Verify that n + kHeaderSize won't overflow.
+  GOOGLE_CHECK_LE(n, std::numeric_limits<size_t>::max() - kHeaderSize);
+  size = std::max(size, kHeaderSize + n);
 
   Block* b = reinterpret_cast<Block*>(options_.block_alloc(size));
   b->pos = kHeaderSize + n;
   b->size = size;
-  if (b->avail() == 0) {
-    // Do not attempt to reuse this block.
-    b->owner = NULL;
-  } else {
-    b->owner = me;
-  }
+  b->owner = me;
 #ifdef ADDRESS_SANITIZER
   // Poison the rest of the block for ASAN. It was unpoisoned by the underlying
   // malloc but it's not yet usable until we return it as part of an allocation.
   ASAN_POISON_MEMORY_REGION(
       reinterpret_cast<char*>(b) + b->pos, b->size - b->pos);
-#endif
+#endif  // ADDRESS_SANITIZER
   return b;
 }
 
 void Arena::AddBlock(Block* b) {
   MutexLock l(&blocks_lock_);
   AddBlockInternal(b);
 }
 
 void Arena::AddBlockInternal(Block* b) {
   b->next = reinterpret_cast<Block*>(google::protobuf::internal::NoBarrier_Load(&blocks_));
@@ skipping 43 matching lines @@
     return SlowAlloc(n);
   }
   return AllocFromBlock(b, n);
 }
 
 void* Arena::AllocFromBlock(Block* b, size_t n) {
   size_t p = b->pos;
   b->pos = p + n;
 #ifdef ADDRESS_SANITIZER
   ASAN_UNPOISON_MEMORY_REGION(reinterpret_cast<char*>(b) + p, n);
-#endif
+#endif  // ADDRESS_SANITIZER
   return reinterpret_cast<char*>(b) + p;
 }
 
 void* Arena::SlowAlloc(size_t n) {
   void* me = &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) {
     SetThreadCacheBlock(b);
     google::protobuf::internal::NoBarrier_Store(&hint_, reinterpret_cast<google::protobuf::internal::AtomicWord>(b));
     return AllocFromBlock(b, n);
   }
   b = NewBlock(me, b, n, options_.start_block_size, options_.max_block_size);
   AddBlock(b);
-  if (b->owner == me) {  // If this block can be reused (see NewBlock()).
-    SetThreadCacheBlock(b);
-  }
+  SetThreadCacheBlock(b);
   return reinterpret_cast<char*>(b) + kHeaderSize;
 }
 
 uint64 Arena::SpaceAllocated() const {
   uint64 space_allocated = 0;
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::NoBarrier_Load(&blocks_));
   while (b != NULL) {
     space_allocated += (b->size);
     b = b->next;
   }
   return space_allocated;
 }
 
 uint64 Arena::SpaceUsed() const {
   uint64 space_used = 0;
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::NoBarrier_Load(&blocks_));
   while (b != NULL) {
     space_used += (b->pos - kHeaderSize);
     b = b->next;
   }
   return space_used;
 }
 
-pair<uint64, uint64> Arena::SpaceAllocatedAndUsed() const {
+std::pair<uint64, uint64> Arena::SpaceAllocatedAndUsed() const {
   uint64 allocated = 0;
   uint64 used = 0;
 
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::NoBarrier_Load(&blocks_));
   while (b != NULL) {
     allocated += b->size;
     used += (b->pos - kHeaderSize);
     b = b->next;
   }
   return std::make_pair(allocated, used);
 }
 
 uint64 Arena::FreeBlocks() {
   uint64 space_allocated = 0;
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::NoBarrier_Load(&blocks_));
   Block* first_block = NULL;
   while (b != NULL) {
     space_allocated += (b->size);
     Block* next = b->next;
     if (next != NULL) {
+#ifdef ADDRESS_SANITIZER
+      // This memory was provided by the underlying allocator as unpoisoned, so
+      // return it in an unpoisoned state.
+      ASAN_UNPOISON_MEMORY_REGION(reinterpret_cast<char*>(b), b->size);
+#endif  // ADDRESS_SANITIZER
       options_.block_dealloc(b, b->size);
     } else {
       if (owns_first_block_) {
+#ifdef ADDRESS_SANITIZER
+        // This memory was provided by the underlying allocator as unpoisoned,
+        // so return it in an unpoisoned state.
+        ASAN_UNPOISON_MEMORY_REGION(reinterpret_cast<char*>(b), b->size);
+#endif  // ADDRESS_SANITIZER
         options_.block_dealloc(b, b->size);
       } else {
         // User passed in the first block, skip free'ing the memory.
         first_block = b;
       }
     }
     b = next;
   }
   blocks_ = 0;
   hint_ = 0;
@@ skipping 26 matching lines @@
   // entry per thread.
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::Acquire_Load(&blocks_));
   while (b != NULL && b->owner != me) {
     b = b->next;
   }
   return b;
 }
 
 }  // namespace protobuf
 }  // namespace google