third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/stubs/port.h

 // 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 42 matching lines @@
   #if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
     #define PROTOBUF_LITTLE_ENDIAN 1
   #endif
   #if _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
     // If MSVC has "/RTCc" set, it will complain about truncating casts at
     // runtime.  This file contains some intentional truncating casts.
     #pragma runtime_checks("c", off)
   #endif
 #else
   #include <sys/param.h>   // __BYTE_ORDER
+  #if defined(__OpenBSD__)
+    #include <endian.h>
+  #endif
   #if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
-         (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN)) && \
+         (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) || \
+         (defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN)) && \
       !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
     #define PROTOBUF_LITTLE_ENDIAN 1
   #endif
 #endif
 
 // The macros defined below are required in order to make protobuf_lite a
 // component on all platforms. See http://crbug.com/172800.
 #if defined(COMPONENT_BUILD) && defined(PROTOBUF_USE_DLLS)
   #if defined(_MSC_VER)
     #ifdef LIBPROTOBUF_EXPORTS
@@ skipping 43 matching lines @@
 typedef signed __int8  int8;
 typedef __int16 int16;
 typedef __int32 int32;
 typedef __int64 int64;
 
 typedef unsigned __int8  uint8;
 typedef unsigned __int16 uint16;
 typedef unsigned __int32 uint32;
 typedef unsigned __int64 uint64;
 #else
-typedef int8_t  int8;
+typedef int8_t int8;
 typedef int16_t int16;
 typedef int32_t int32;
 typedef int64_t int64;
 
-typedef uint8_t  uint8;
+typedef uint8_t uint8;
 typedef uint16_t uint16;
 typedef uint32_t uint32;
 typedef uint64_t uint64;
 #endif
 
 // long long macros to be used because gcc and vc++ use different suffixes,
 // and different size specifiers in format strings
 #undef GOOGLE_LONGLONG
 #undef GOOGLE_ULONGLONG
 #undef GOOGLE_LL_FORMAT
 
 #ifdef _MSC_VER
 #define GOOGLE_LONGLONG(x) x##I64
 #define GOOGLE_ULONGLONG(x) x##UI64
 #define GOOGLE_LL_FORMAT "I64"  // As in printf("%I64d", ...)
 #else
+// By long long, we actually mean int64.
 #define GOOGLE_LONGLONG(x) INT64_C(x)
 #define GOOGLE_ULONGLONG(x) UINT64_C(x)
+// Used to format real long long integers.
 #define GOOGLE_LL_FORMAT "ll"  // As in "%lld". Note that "q" is poor form also.
 #endif
 
 static const int32 kint32max = 0x7FFFFFFF;
 static const int32 kint32min = -kint32max - 1;
 static const int64 kint64max = GOOGLE_LONGLONG(0x7FFFFFFFFFFFFFFF);
 static const int64 kint64min = -kint64max - 1;
 static const uint32 kuint32max = 0xFFFFFFFFu;
 static const uint64 kuint64max = GOOGLE_ULONGLONG(0xFFFFFFFFFFFFFFFF);
 
@@ skipping 21 matching lines @@
 #define GOOGLE_ATTRIBUTE_NOINLINE __attribute__ ((noinline))
 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
 // Seems to have been around since at least Visual Studio 2005
 #define GOOGLE_ATTRIBUTE_NOINLINE __declspec(noinline)
 #else
 // Other compilers will have to figure it out for themselves.
 #define GOOGLE_ATTRIBUTE_NOINLINE
 #endif
 #endif
 
+#ifndef GOOGLE_ATTRIBUTE_NORETURN
+#ifdef __GNUC__
+// Tell the compiler that a given function never returns.
+#define GOOGLE_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#else
+#define GOOGLE_ATTRIBUTE_NORETURN
+#endif
+#endif
+
 #ifndef GOOGLE_ATTRIBUTE_DEPRECATED
 #ifdef __GNUC__
 // If the method/variable/type is used anywhere, produce a warning.
 #define GOOGLE_ATTRIBUTE_DEPRECATED __attribute__((deprecated))
 #else
 #define GOOGLE_ATTRIBUTE_DEPRECATED
 #endif
 #endif
 
 #ifndef GOOGLE_PREDICT_TRUE
@@ skipping 82 matching lines @@
   memcpy(p, &v, sizeof v);
 }
 #endif
 
 #if defined(_MSC_VER)
 #define GOOGLE_THREAD_LOCAL __declspec(thread)
 #else
 #define GOOGLE_THREAD_LOCAL __thread
 #endif
 
-// The following guarantees declaration of the byte swap functions, and
-// defines __BYTE_ORDER for MSVC
+// The following guarantees declaration of the byte swap functions.
 #ifdef _MSC_VER
-#define __BYTE_ORDER __LITTLE_ENDIAN
 #define bswap_16(x) _byteswap_ushort(x)
 #define bswap_32(x) _byteswap_ulong(x)
 #define bswap_64(x) _byteswap_uint64(x)
 
 #elif defined(__APPLE__)
 // Mac OS X / Darwin features
 #define bswap_16(x) OSSwapInt16(x)
 #define bswap_32(x) OSSwapInt32(x)
 #define bswap_64(x) OSSwapInt64(x)
 
@@ skipping 18 matching lines @@
           ((x & GOOGLE_ULONGLONG(0xFF00000000)) >> 8) |
           ((x & GOOGLE_ULONGLONG(0xFF0000000000)) >> 24) |
           ((x & GOOGLE_ULONGLONG(0xFF000000000000)) >> 40) |
           ((x & GOOGLE_ULONGLONG(0xFF00000000000000)) >> 56));
 }
 #define bswap_64(x) bswap_64(x)
 
 #endif
 
 // ===================================================================
+// from google3/util/bits/bits.h
+
+class Bits {
+ public:
+  static uint32 Log2FloorNonZero(uint32 n) {
+#if defined(__GNUC__)
+  return 31 ^ __builtin_clz(n);
+#elif defined(COMPILER_MSVC) && defined(_M_IX86)
+  _asm {
+    bsr ebx, n
+    mov n, ebx
+  }
+  return n;
+#else
+  return Log2FloorNonZero_Portable(n);
+#endif
+  }
+
+  static uint64 Log2FloorNonZero64(uint64 n) {
+#if defined(__GNUC__)
+  return 63 ^ __builtin_clzll(n);
+#else
+  return Log2FloorNonZero64_Portable(n);
+#endif
+  }
+ private:
+  static int Log2FloorNonZero_Portable(uint32 n) {
+    if (n == 0)
+      return -1;
+    int log = 0;
+    uint32 value = n;
+    for (int i = 4; i >= 0; --i) {
+      int shift = (1 << i);
+      uint32 x = value >> shift;
+      if (x != 0) {
+        value = x;
+        log += shift;
+      }
+    }
+    assert(value == 1);
+    return log;
+  }
+
+  static int Log2FloorNonZero64_Portable(uint64 n) {
+    const uint32 topbits = static_cast<uint32>(n >> 32);
+    if (topbits == 0) {
+      // Top bits are zero, so scan in bottom bits
+      return Log2FloorNonZero(static_cast<uint32>(n));
+    } else {
+      return 32 + Log2FloorNonZero(topbits);
+    }
+  }
+};
+
+// ===================================================================
 // from google3/util/endian/endian.h
 LIBPROTOBUF_EXPORT uint32 ghtonl(uint32 x);
 
 class BigEndian {
  public:
 #ifdef PROTOBUF_LITTLE_ENDIAN
 
   static uint16 FromHost16(uint16 x) { return bswap_16(x); }
   static uint16 ToHost16(uint16 x) { return bswap_16(x); }
 
@@ skipping 44 matching lines @@
   static void Store64(void *p, uint64 v) {
     GOOGLE_UNALIGNED_STORE64(p, FromHost64(v));
   }
 };
 
 
 }  // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_STUBS_PORT_H_