Update to 2025-09-24 google3 version (#454)

* Bump required versions
  * abseil-cpp: LTS 20250814
  * clang: 14
  * CMake: 3.22
  * OpenSSL: 1.1
* New functions
  * MutableS2ShapeIndex::Remove()
  * S2EdgeVectorShape::set_dimension()
  * S2Polygon::MakeFull()
* Add tests for ExactFloat

Author: jmr

.github/workflows/build.yml

@@ -35,7 +35,7 @@ jobs:
       - uses: zacharyburnett/setup-abseil-cpp@713a4383f10b05948a6d9d4906056063c8da1168 # Not a release, but has #423 fix.
         with:
           cmake-build-args: "-DCMAKE_CXX_STANDARD=17 -DABSL_PROPAGATE_CXX_STD=ON -DABSL_ENABLE_INSTALL=ON -DBUILD_TESTING=off -DCMAKE_POSITION_INDEPENDENT_CODE=ON"
-          abseil-version: "20250512.1"
+          abseil-version: "20250814.1"
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - run: mkdir build
       - run: cmake -DCMAKE_CXX_STANDARD=17 -DCMAKE_PREFIX_PATH=/usr/local/ -DBUILD_TESTS=OFF ..

.github/workflows/test.yml

@@ -36,7 +36,7 @@ jobs:
       - uses: zacharyburnett/setup-abseil-cpp@713a4383f10b05948a6d9d4906056063c8da1168 # Not a release, but has #423 fix.
         with:
           cmake-build-args: "-DCMAKE_CXX_STANDARD=17 -DABSL_PROPAGATE_CXX_STD=ON -DABSL_ENABLE_INSTALL=ON -DBUILD_TESTING=off -DCMAKE_POSITION_INDEPENDENT_CODE=ON"
-          abseil-version: "20250512.1"
+          abseil-version: "20250814.1"
       - name: retrieve googletest v${{ env.GOOGLETEST_VERSION }}
         run: |
           wget https://github.com/google/googletest/releases/download/v${{ env.GOOGLETEST_VERSION }}/googletest-${{ env.GOOGLETEST_VERSION }}.tar.gz

CMakeLists.txt

@@ -443,8 +443,6 @@ if(S2_ENABLE_INSTALL)
           DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/s2/testing")
   install(FILES src/s2/util/bitmap/bitmap.h
           DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/s2/util/bitmap")
-  install(FILES src/s2/util/bits/bits.h
-          DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/s2/util/bits")
   install(FILES src/s2/util/coding/coder.h
                 src/s2/util/coding/varint.h
           DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/s2/util/coding")
@@ -455,6 +453,7 @@ if(S2_ENABLE_INSTALL)
                 src/s2/util/gtl/dense_hash_set.h
                 src/s2/util/gtl/densehashtable.h
                 src/s2/util/gtl/hashtable_common.h
+                src/s2/util/gtl/requires.h
           DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/s2/util/gtl")
   install(FILES src/s2/util/hash/mix.h
           DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/s2/util/hash")
@@ -622,7 +621,8 @@ if (BUILD_TESTS)
       src/s2/s2winding_operation_test.cc
       src/s2/s2wrapped_shape_test.cc
       src/s2/sequence_lexicon_test.cc
-      src/s2/value_lexicon_test.cc)
+      src/s2/value_lexicon_test.cc
+      src/s2/util/math/exactfloat/exactfloat_test.cc)
 
   enable_testing()
 

README.md

@@ -52,12 +52,12 @@ This issue may require revision of boringssl or exactfloat.
 
 *   We aim to support all platforms supported by the
     [Google foundational C++ support policy](https://opensource.google/documentation/policies/cplusplus-support)
-*   [CMake](http://www.cmake.org/) >= 3.5
+*   [CMake](http://www.cmake.org/) >= 3.22
 *   A C++ compiler with C++17 support, such as
     [g++ >= 7.5](https://gcc.gnu.org/) or
-    [clang >= 7.0.0](https://clang.llvm.org/)
+    [clang >= 14.0.0](https://clang.llvm.org/)
 *   [Abseil](https://github.com/abseil/abseil-cpp) >= LTS
-    [`20250512`](https://github.com/abseil/abseil-cpp/releases/tag/20250512.1)
+    [`20250814`](https://github.com/abseil/abseil-cpp/releases/tag/20250814.1)
     (standard library extensions)
 *   [OpenSSL](https://github.com/openssl/openssl) (for its bignum library)
 *   [googletest testing framework >= 1.10](https://github.com/google/googletest)

src/s2/base/port.h

@@ -19,7 +19,6 @@
 // This file contains things that are not used in third_party/absl but needed by
 // s2geometry. It is structured into the following high-level categories:
 // - Utility functions
-// - Endianness
 // - Performance optimization (alignment)
 
 #include <cstdint>
@@ -41,55 +40,6 @@ inline void sized_delete_array(void *ptr, size_t size) {
 }
 }  // namespace base
 
-// -----------------------------------------------------------------------------
-// Endianness
-// -----------------------------------------------------------------------------
-
-// IS_LITTLE_ENDIAN, IS_BIG_ENDIAN
-#if defined(__linux__)
-#include <endian.h>
-
-#elif defined(__APPLE__)
-
-// BIG_ENDIAN
-#include <machine/endian.h>  // NOLINT(build/include)
-
-/* Let's try and follow the Linux convention */
-#define __BYTE_ORDER BYTE_ORDER
-#define __LITTLE_ENDIAN LITTLE_ENDIAN
-#define __BIG_ENDIAN BIG_ENDIAN
-
-#endif
-
-// defines __BYTE_ORDER
-#ifdef _WIN32
-#define __BYTE_ORDER __LITTLE_ENDIAN
-#define IS_LITTLE_ENDIAN
-#else // _WIN32
-
-// define the macros IS_LITTLE_ENDIAN or IS_BIG_ENDIAN
-// using the above endian definitions from endian.h if
-// endian.h was included
-#ifdef __BYTE_ORDER
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define IS_LITTLE_ENDIAN
-#endif
-
-#if __BYTE_ORDER == __BIG_ENDIAN
-#define IS_BIG_ENDIAN
-#endif
-
-#else  // __BYTE_ORDER
-
-#if defined(__LITTLE_ENDIAN__)
-#define IS_LITTLE_ENDIAN
-#elif defined(__BIG_ENDIAN__)
-#define IS_BIG_ENDIAN
-#endif
-
-#endif  // __BYTE_ORDER
-#endif  // _WIN32
-
 // -----------------------------------------------------------------------------
 // Performance Optimization
 // -----------------------------------------------------------------------------
@@ -100,37 +50,15 @@ inline void sized_delete_array(void *ptr, size_t size) {
 
 // Portable handling of unaligned loads, stores, and copies. These are simply
 // constant-length memcpy calls.
-//
-// TODO(user): These APIs are forked in Abseil, see
-// "third_party/absl/base/internal/unaligned_access.h".
-//
-// The unaligned API is C++ only.  The declarations use C++ features
-// (namespaces, inline) which are absent or incompatible in C.
-#if defined(__cplusplus)
 
 namespace base {
-
-// Can't use ATTRIBUTE_NO_SANITIZE_MEMORY because this file is included before
-// attributes.h is.
-#ifdef __has_attribute
-#if __has_attribute(no_sanitize_memory)
-#define NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
-#endif  // __has_attribute(no_sanitize_memory)
-#endif  // defined __has_attribute
-
-#ifndef NO_SANITIZE_MEMORY
-#define NO_SANITIZE_MEMORY /**/
-#endif
-
 template <typename T>
-T NO_SANITIZE_MEMORY UnalignedLoad(const void *p) {
+T UnalignedLoad(const void *p) {
   T t;
   memcpy(&t, p, sizeof t);
   return t;
 }
 
-#undef NO_SANITIZE_MEMORY
-
 template <typename T>
 void UnalignedStore(void *p, T t) {
   memcpy(p, &t, sizeof t);
@@ -161,6 +89,4 @@ inline void UNALIGNED_STORE64(void *p, uint64_t v) {
   base::UnalignedStore(p, v);
 }
 
-#endif  // defined(__cplusplus), end of unaligned API
-
 #endif  // S2_BASE_PORT_H_

src/s2/base/spinlock.h

@@ -27,38 +27,38 @@ class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
   SpinLock(SpinLock const&) = delete;
   SpinLock& operator=(SpinLock const&) = delete;
 
-  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+  inline void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
     while (locked_.exchange(true, std::memory_order_acquire)) {
       // Spin.
       continue;
     }
   }
 
-  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
+  inline void unlock() ABSL_UNLOCK_FUNCTION() {
     locked_.store(false, std::memory_order_release);
   }
 
-  ABSL_MUST_USE_RESULT inline bool IsHeld() const {
+  [[nodiscard]] inline bool IsHeld() const {
     return locked_.load(std::memory_order_relaxed);
   }
 
  private:
   std::atomic_bool locked_{false};
 };
 
-class ABSL_MUST_USE_RESULT ABSL_SCOPED_LOCKABLE SpinLockHolder {
+class [[nodiscard]] ABSL_SCOPED_LOCKABLE SpinLockHolder {
  public:
-  inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
+  inline explicit SpinLockHolder(SpinLock& l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
       : lock_(l) {
-    lock_->Lock();
+    l.lock();
   }
-  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
+  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_.unlock(); }
 
   SpinLockHolder(const SpinLockHolder&) = delete;
   SpinLockHolder& operator=(const SpinLockHolder&) = delete;
 
  private:
-  SpinLock* lock_;
+  SpinLock& lock_;
 };
 
 #endif  // S2_BASE_SPINLOCK_H_

src/s2/encoded_s2point_vector.cc

@@ -203,9 +203,9 @@ void EncodedS2PointVector::Encode(Encoder* encoder) const {
 
 // Encodes a vector of points, optimizing for (encoding and decoding) speed.
 void EncodeS2PointVectorFast(Span<const S2Point> points, Encoder* encoder) {
-#ifndef IS_LITTLE_ENDIAN
-  ABSL_LOG(FATAL) << "Not implemented on big-endian architectures";
-#endif
+  if constexpr (absl::endian::native != absl::endian::little) {
+    ABSL_LOG(FATAL) << "Not implemented on big-endian architectures";
+  }
 
   // This function always uses the UNCOMPRESSED encoding.  The header consists
   // of a varint64 in the following format:
@@ -222,19 +222,24 @@ void EncodeS2PointVectorFast(Span<const S2Point> points, Encoder* encoder) {
 }
 
 bool EncodedS2PointVector::InitUncompressedFormat(Decoder* decoder) {
-#if !defined(IS_LITTLE_ENDIAN) || defined(__arm__)
-  // TODO(b/231674214): Make this work on platforms that don't support
-  // unaligned 64-bit little-endian reads, e.g. by falling back to
-  //
-  //   bit_cast<double>(little_endian::Load64()).
-  //
-  // Maybe the compiler is smart enough that we can do this all the time,
-  // but more likely we will need two cases using the #ifdef above.
-  // (Note that even ARMv7 does not support unaligned 64-bit loads.)
-  ABSL_LOG(ERROR)
-      << "Needs architecture with 64-bit little-endian unaligned loads";
-  return false;
+#ifdef __arm__
+  constexpr bool kIsArm32 = true;
+#else
+  constexpr bool kIsArm32 = false;
 #endif
+  if constexpr (absl::endian::native != absl::endian::little || kIsArm32) {
+    // TODO(b/231674214): Make this work on platforms that don't support
+    // unaligned 64-bit little-endian reads, e.g. by falling back to
+    //
+    //   bit_cast<double>(LittleEndian::Load64()).
+    //
+    // Maybe the compiler is smart enough that we can do this all the time,
+    // but more likely we will need two cases using the #ifdef above.
+    // (Note that even ARMv7 does not support unaligned 64-bit loads.)
+    ABSL_LOG(ERROR)
+        << "Needs architecture with 64-bit little-endian unaligned loads";
+    return false;
+  }
 
   uint64_t size;
   if (!decoder->get_varint64(&size)) return false;

src/s2/encoded_s2shape_index.cc

@@ -81,7 +81,7 @@ const S2ShapeIndexCell* EncodedS2ShapeIndex::GetCell(int i) const {
   }
   // Recheck cell_decoded(i) once we hold the lock in case another thread
   // has decoded this cell in the meantime.
-  SpinLockHolder l(&cells_lock_);
+  SpinLockHolder l(cells_lock_);
   if (cell_decoded(i)) return cells_[i];
 
   // Update the cell, setting cells_[i] before cell_decoded(i).

src/s2/internal/s2index_cell_data.h

@@ -142,7 +142,7 @@ class S2IndexCellData {
   // Returns an S2Cell instance for the current cell.
   const S2Cell& cell() const {
     if (!s2cell_set_.load(std::memory_order_acquire)) {
-      absl::MutexLock lock(&lock_);
+      absl::MutexLock lock(lock_);
       if (!s2cell_set_.load(std::memory_order_relaxed)) {
         s2cell_ = S2Cell(cell_id_);
         s2cell_set_.store(true, std::memory_order_release);
@@ -156,7 +156,7 @@ class S2IndexCellData {
   // Returns the center point of the current cell.
   const S2Point& center() const {
     if (!center_set_.load(std::memory_order_acquire)) {
-      absl::MutexLock lock(&lock_);
+      absl::MutexLock lock(lock_);
       if (!center_set_.load(std::memory_order_relaxed)) {
         cell_center_ = cell_id_.ToPoint();
         center_set_.store(true, std::memory_order_release);