From a4c3ffff11eec0ee45742f915c255e9f870b7e0f Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Mon, 29 Oct 2018 15:53:34 -0700 Subject: Export of internal Abseil changes. -- ba4dd47492748bd630462eb68b7959037fc6a11a by Abseil Team : Work around nvcc 9.0 compiler bug for open-source Tensorflow build. With the current implementation, when I (unintentionally and transitively) include absl/types/optional.h in a CUDA compilation unit, I get the following nvcc error message: INFO: From Compiling tensorflow/core/kernels/crop_and_resize_op_gpu.cu.cc: external/com_google_absl/absl/types/optional.h: In member function 'void absl::optional_internal::optional_data_dtor_base >::destruct()': external/com_google_absl/absl/types/optional.h:185:50: error: '__T0' was not declared in this scope data_.~T(); I've also seen similar compilation failures online, for flat_hash_map: https://devtalk.nvidia.com/default/topic/1042599/nvcc-preprocessor-bug-causes-compilation-failure/ The bug is always around unnamed template parameters. Therefore, the workaround is to make them named. PiperOrigin-RevId: 219208288 -- dad2f40cb2e8d5017660985ef6fb57f3c3cdcc80 by CJ Johnson : Adds internal macros for catching and throwing unknown exception types PiperOrigin-RevId: 219207362 -- 0a9840328d2d86e8420b853435fdbf1f7a19d931 by Abseil Team : Fix typo in mutex.h comments. PiperOrigin-RevId: 219199397 -- 0d576dc7597564210bfdf91518075064756f0bf4 by Matt Calabrese : Internal change. PiperOrigin-RevId: 219185475 -- 66be156095571959fb19a76da8ad0b53ec37658e by Abseil Team : Fix alignment conformance for VS 2017 >= 15.8 (fix #193) PiperOrigin-RevId: 219129894 -- a6e1825a12587945f8194677ccfdcaba6f7aad1d by Abseil Team : Reapply PR #173 PiperOrigin-RevId: 219129361 -- cf72ade4881b25acc6ccaea468f69793a0fdce32 by Abseil Team : Update .gitignore PiperOrigin-RevId: 219127495 -- 0537490c6348a2cb489abe15638928ac5aa6982a by Jon Cohen : Small refactor and reformat of error messages from the exception safety test framework. PiperOrigin-RevId: 218927773 -- 4c556ca45fa25698ad12002a00c713aeceefab73 by CJ Johnson : Updates the inlined vector swap tests to check for number of moves that took place if available PiperOrigin-RevId: 218900777 -- dcbfda0021a1e6dfa9586986b1269c06ec394053 by Mark Barolak : Add parens around calls to std::numeric_limits<>::min and std::numeric_limits<>::max to prevent compilation errors on Windows platforms where min and max are defined as macros. PiperOrigin-RevId: 218888700 GitOrigin-RevId: ba4dd47492748bd630462eb68b7959037fc6a11a Change-Id: I0e393958eb8cb501b85f6114979f6d4d86ed996c --- .gitignore | 6 ++++ CMakeLists.txt | 10 +++++- absl/base/internal/exception_safety_testing.h | 35 +++++++++++-------- absl/base/macros.h | 10 ++++++ absl/container/CMakeLists.txt | 17 ++++++++-- absl/container/fixed_array.h | 2 +- absl/container/inlined_vector.h | 2 +- absl/container/inlined_vector_test.cc | 12 ++++--- absl/container/internal/hash_policy_testing.h | 2 +- absl/container/internal/raw_hash_set.h | 4 +-- absl/copts.bzl | 6 +++- absl/memory/memory.h | 47 ++++++++------------------ absl/numeric/int128.h | 16 ++++----- absl/strings/internal/numbers_test_common.h | 23 +++++++------ absl/strings/internal/str_format/arg.h | 8 ++--- absl/strings/string_view.h | 2 +- absl/synchronization/internal/kernel_timeout.h | 10 +++--- absl/synchronization/mutex.h | 2 +- absl/time/time.h | 33 ++++++++++-------- absl/types/optional.h | 10 +++--- 20 files changed, 147 insertions(+), 110 deletions(-) diff --git a/.gitignore b/.gitignore index 886f4432..8aba599f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,8 @@ # Ignore all bazel-* symlinks. /bazel-* +# Ignore CMake usual build directory +build +# Ignore Vim files +*.swp +# Ignore QtCreator Project file +CMakeLists.txt.user diff --git a/CMakeLists.txt b/CMakeLists.txt index 9a7e1031..ea45dcaa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,7 +33,15 @@ if (MSVC) # /wd4267 conversion from 'size_t' to 'type2' # /wd4800 force value to bool 'true' or 'false' (performance warning) add_compile_options(/W3 /wd4005 /wd4068 /wd4244 /wd4267 /wd4800) - add_definitions(/DNOMINMAX /DWIN32_LEAN_AND_MEAN=1 /D_CRT_SECURE_NO_WARNINGS /D_SCL_SECURE_NO_WARNINGS) + # /D_ENABLE_EXTENDED_ALIGNED_STORAGE Introduced in VS 2017 15.8, before the + # member type would non-conformingly have an alignment of only alignof(max_align_t). + add_definitions( + /DNOMINMAX + /DWIN32_LEAN_AND_MEAN=1 + /D_CRT_SECURE_NO_WARNINGS + /D_SCL_SECURE_NO_WARNINGS + /D_ENABLE_EXTENDED_ALIGNED_STORAGE + ) else() set(ABSL_STD_CXX_FLAG "-std=c++11" CACHE STRING "c++ std flag (default: c++11)") endif() diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h index 429f5c2f..0ecc4177 100644 --- a/absl/base/internal/exception_safety_testing.h +++ b/absl/base/internal/exception_safety_testing.h @@ -127,10 +127,8 @@ class ConstructorTracker { void* address = it.first; TrackedAddress& tracked_address = it.second; if (tracked_address.is_alive) { - ADD_FAILURE() << "Object at address " << address - << " with countdown of " << countdown_ - << " was not destroyed [" << tracked_address.description - << "]"; + ADD_FAILURE() << ErrorMessage(address, tracked_address.description, + countdown_, "Object was not destroyed."); } } } @@ -141,11 +139,11 @@ class ConstructorTracker { TrackedAddress& tracked_address = current_tracker_instance_->address_map_[address]; if (tracked_address.is_alive) { - ADD_FAILURE() << "Object at address " << address << " with countdown of " - << current_tracker_instance_->countdown_ - << " was re-constructed. Previously: [" - << tracked_address.description << "] Now: [" << description - << "]"; + ADD_FAILURE() << ErrorMessage( + address, tracked_address.description, + current_tracker_instance_->countdown_, + "Object was re-constructed. Current object was constructed by " + + description); } tracked_address = {true, std::move(description)}; } @@ -159,10 +157,9 @@ class ConstructorTracker { TrackedAddress& tracked_address = it->second; if (!tracked_address.is_alive) { - ADD_FAILURE() << "Object at address " << address << " with countdown of " - << current_tracker_instance_->countdown_ - << " was re-destroyed or created prior to construction " - << "tracking [" << tracked_address.description << "]"; + ADD_FAILURE() << ErrorMessage(address, tracked_address.description, + current_tracker_instance_->countdown_, + "Object was re-destroyed."); } tracked_address.is_alive = false; } @@ -172,6 +169,16 @@ class ConstructorTracker { return current_tracker_instance_ != nullptr; } + static std::string ErrorMessage(void* address, const std::string& address_description, + int countdown, const std::string& error_description) { + return absl::Substitute( + "With coundtown at $0:\n" + " $1\n" + " Object originally constructed by $2\n" + " Object address: $3\n", + countdown, error_description, address_description, address); + } + std::unordered_map address_map_; int countdown_; @@ -709,7 +716,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject { } size_type max_size() const noexcept { - return std::numeric_limits::max() / sizeof(value_type); + return (std::numeric_limits::max)() / sizeof(value_type); } ThrowingAllocator select_on_container_copy_construction() noexcept( diff --git a/absl/base/macros.h b/absl/base/macros.h index ca3d5edb..9e7ab375 100644 --- a/absl/base/macros.h +++ b/absl/base/macros.h @@ -199,4 +199,14 @@ enum LinkerInitialized { : [] { assert(false && #expr); }()) // NOLINT #endif +#ifdef ABSL_HAVE_EXCEPTIONS +#define ABSL_INTERNAL_TRY try +#define ABSL_INTERNAL_CATCH_ANY catch (...) +#define ABSL_INTERNAL_RETHROW do { throw; } while (false) +#else // ABSL_HAVE_EXCEPTIONS +#define ABSL_INTERNAL_TRY if (true) +#define ABSL_INTERNAL_CATCH_ANY else if (false) +#define ABSL_INTERNAL_RETHROW do {} while (false) +#endif // ABSL_HAVE_EXCEPTIONS + #endif // ABSL_BASE_MACROS_H_ diff --git a/absl/container/CMakeLists.txt b/absl/container/CMakeLists.txt index 4d2e1554..72113e19 100644 --- a/absl/container/CMakeLists.txt +++ b/absl/container/CMakeLists.txt @@ -48,14 +48,15 @@ list(APPEND CONTAINER_INTERNAL_HEADERS ) -absl_header_library( +absl_library( TARGET absl_container + SOURCES + "internal/raw_hash_set.cc" EXPORT_NAME container ) - # ## TESTS # @@ -162,3 +163,15 @@ absl_test( PUBLIC_LIBRARIES ${TEST_INSTANCE_TRACKER_TEST_PUBLIC_LIBRARIES} ) + +absl_test( + TARGET + raw_hash_set_test + SOURCES + "internal/raw_hash_set_test.cc" + PUBLIC_LIBRARIES + absl::base + absl::hash + absl_internal_throw_delegate + test_instance_tracker_lib +) diff --git a/absl/container/fixed_array.h b/absl/container/fixed_array.h index fe67dcee..6da84411 100644 --- a/absl/container/fixed_array.h +++ b/absl/container/fixed_array.h @@ -188,7 +188,7 @@ class FixedArray { // `FixedArray`. This is equivalent to the most possible addressable bytes // over the number of bytes taken by T. constexpr size_type max_size() const { - return std::numeric_limits::max() / sizeof(value_type); + return (std::numeric_limits::max)() / sizeof(value_type); } // FixedArray::empty() diff --git a/absl/container/inlined_vector.h b/absl/container/inlined_vector.h index 12756bb8..0d773e5a 100644 --- a/absl/container/inlined_vector.h +++ b/absl/container/inlined_vector.h @@ -264,7 +264,7 @@ class InlinedVector { // One bit of the size storage is used to indicate whether the inlined // vector is allocated; as a result, the maximum size of the container that // we can express is half of the max for our size type. - return std::numeric_limits::max() / 2; + return (std::numeric_limits::max)() / 2; } // InlinedVector::data() diff --git a/absl/container/inlined_vector_test.cc b/absl/container/inlined_vector_test.cc index 08dcd3ef..5485f454 100644 --- a/absl/container/inlined_vector_test.cc +++ b/absl/container/inlined_vector_test.cc @@ -906,6 +906,8 @@ TYPED_TEST_P(InstanceTest, Swap) { InstanceTracker tracker; InstanceVec a, b; const size_t inlined_capacity = a.capacity(); + auto min_len = std::min(l1, l2); + auto max_len = std::max(l1, l2); for (int i = 0; i < l1; i++) a.push_back(Instance(i)); for (int i = 0; i < l2; i++) b.push_back(Instance(100+i)); EXPECT_EQ(tracker.instances(), l1 + l2); @@ -919,15 +921,15 @@ TYPED_TEST_P(InstanceTest, Swap) { EXPECT_EQ(tracker.swaps(), 0); // Allocations are swapped. EXPECT_EQ(tracker.moves(), 0); } else if (a.size() <= inlined_capacity && b.size() <= inlined_capacity) { - EXPECT_EQ(tracker.swaps(), std::min(l1, l2)); - // TODO(bsamwel): This should use moves when the type is movable. - EXPECT_EQ(tracker.copies(), std::max(l1, l2) - std::min(l1, l2)); + EXPECT_EQ(tracker.swaps(), min_len); + EXPECT_EQ((tracker.moves() ? tracker.moves() : tracker.copies()), + max_len - min_len); } else { // One is allocated and the other isn't. The allocation is transferred // without copying elements, and the inlined instances are copied/moved. EXPECT_EQ(tracker.swaps(), 0); - // TODO(bsamwel): This should use moves when the type is movable. - EXPECT_EQ(tracker.copies(), std::min(l1, l2)); + EXPECT_EQ((tracker.moves() ? tracker.moves() : tracker.copies()), + min_len); } EXPECT_EQ(l1, b.size()); diff --git a/absl/container/internal/hash_policy_testing.h b/absl/container/internal/hash_policy_testing.h index ffc76ead..38bbec77 100644 --- a/absl/container/internal/hash_policy_testing.h +++ b/absl/container/internal/hash_policy_testing.h @@ -139,7 +139,7 @@ struct Alloc : std::allocator { friend bool operator!=(const Alloc& a, const Alloc& b) { return !(a == b); } private: - size_t id_ = std::numeric_limits::max(); + size_t id_ = (std::numeric_limits::max)(); }; template diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h index 40bdb71b..aa423b25 100644 --- a/absl/container/internal/raw_hash_set.h +++ b/absl/container/internal/raw_hash_set.h @@ -477,7 +477,7 @@ inline size_t NormalizeCapacity(size_t n) { constexpr size_t kMinCapacity = Group::kWidth - 1; return n <= kMinCapacity ? kMinCapacity - : std::numeric_limits::max() >> LeadingZeros(n); + : (std::numeric_limits::max)() >> LeadingZeros(n); } // The node_handle concept from C++17. @@ -1022,7 +1022,7 @@ class raw_hash_set { bool empty() const { return !size(); } size_t size() const { return size_; } size_t capacity() const { return capacity_; } - size_t max_size() const { return std::numeric_limits::max(); } + size_t max_size() const { return (std::numeric_limits::max)(); } void clear() { // Iterating over this container is O(bucket_count()). When bucket_count() diff --git a/absl/copts.bzl b/absl/copts.bzl index 5c508f17..49bb697d 100644 --- a/absl/copts.bzl +++ b/absl/copts.bzl @@ -130,7 +130,11 @@ MSVC_FLAGS = [ "/wd4800", # forcing value to bool 'true' or 'false' (performance warning) "/DNOMINMAX", # Don't define min and max macros (windows.h) "/DWIN32_LEAN_AND_MEAN", # Don't bloat namespace with incompatible winsock versions. - "/D_CRT_SECURE_NO_WARNINGS", # Don't warn about usage of insecure C functions + "/D_CRT_SECURE_NO_WARNINGS", # Don't warn about usage of insecure C functions. + "/D_SCL_SECURE_NO_WARNINGS", # Don't warm when the compiler encounters a function or + # variable that is marked as deprecated (same as /wd4996). + "/D_ENABLE_EXTENDED_ALIGNED_STORAGE", # Introduced in VS 2017 15.8, + # before the member type would non-conformingly have an alignment of only alignof(max_align_t). ] MSVC_TEST_FLAGS = [ diff --git a/absl/memory/memory.h b/absl/memory/memory.h index 1eaec0f4..8bf4fe82 100644 --- a/absl/memory/memory.h +++ b/absl/memory/memory.h @@ -599,7 +599,7 @@ struct allocator_traits { return a.max_size(); } static size_type max_size_impl(char, const Alloc&) { - return std::numeric_limits::max() / sizeof(value_type); + return (std::numeric_limits::max)() / sizeof(value_type); } template @@ -655,59 +655,42 @@ struct default_allocator_is_nothrow : std::false_type {}; #endif namespace memory_internal { -#ifdef ABSL_HAVE_EXCEPTIONS // ConstructRange template void ConstructRange(Allocator& alloc, Iterator first, Iterator last, const Args&... args) { for (Iterator cur = first; cur != last; ++cur) { - try { - std::allocator_traits::construct(alloc, cur, args...); - } catch (...) { + ABSL_INTERNAL_TRY { + std::allocator_traits::construct(alloc, std::addressof(*cur), + args...); + } + ABSL_INTERNAL_CATCH_ANY { while (cur != first) { --cur; - std::allocator_traits::destroy(alloc, cur); + std::allocator_traits::destroy(alloc, std::addressof(*cur)); } - throw; + ABSL_INTERNAL_RETHROW; } } } -#else // ABSL_HAVE_EXCEPTIONS // ConstructRange -template -void ConstructRange(Allocator& alloc, Iterator first, Iterator last, - const Args&... args) { - for (; first != last; ++first) { - std::allocator_traits::construct(alloc, first, args...); - } -} -#endif // ABSL_HAVE_EXCEPTIONS // ConstructRange -#ifdef ABSL_HAVE_EXCEPTIONS // CopyRange template void CopyRange(Allocator& alloc, Iterator destination, InputIterator first, InputIterator last) { for (Iterator cur = destination; first != last; static_cast(++cur), static_cast(++first)) { - try { - std::allocator_traits::construct(alloc, cur, *first); - } catch (...) { + ABSL_INTERNAL_TRY { + std::allocator_traits::construct(alloc, std::addressof(*cur), + *first); + } + ABSL_INTERNAL_CATCH_ANY { while (cur != destination) { --cur; - std::allocator_traits::destroy(alloc, cur); + std::allocator_traits::destroy(alloc, std::addressof(*cur)); } - throw; + ABSL_INTERNAL_RETHROW; } } } -#else // ABSL_HAVE_EXCEPTIONS // CopyRange -template -void CopyRange(Allocator& alloc, Iterator destination, InputIterator first, - InputIterator last) { - for (; first != last; - static_cast(++destination), static_cast(++first)) { - std::allocator_traits::construct(alloc, destination, *first); - } -} -#endif // ABSL_HAVE_EXCEPTIONS // CopyRange } // namespace memory_internal } // namespace absl diff --git a/absl/numeric/int128.h b/absl/numeric/int128.h index 79b62a75..5d14a4a8 100644 --- a/absl/numeric/int128.h +++ b/absl/numeric/int128.h @@ -227,8 +227,8 @@ std::ostream& operator<<(std::ostream& os, uint128 v); // TODO(strel) add operator>>(std::istream&, uint128) constexpr uint128 Uint128Max() { - return uint128(std::numeric_limits::max(), - std::numeric_limits::max()); + return uint128((std::numeric_limits::max)(), + (std::numeric_limits::max)()); } } // namespace absl @@ -384,13 +384,13 @@ constexpr uint128::uint128(uint64_t high, uint64_t low) constexpr uint128::uint128(int v) : lo_{static_cast(v)}, - hi_{v < 0 ? std::numeric_limits::max() : 0} {} + hi_{v < 0 ? (std::numeric_limits::max)() : 0} {} constexpr uint128::uint128(long v) // NOLINT(runtime/int) : lo_{static_cast(v)}, - hi_{v < 0 ? std::numeric_limits::max() : 0} {} + hi_{v < 0 ? (std::numeric_limits::max)() : 0} {} constexpr uint128::uint128(long long v) // NOLINT(runtime/int) : lo_{static_cast(v)}, - hi_{v < 0 ? std::numeric_limits::max() : 0} {} + hi_{v < 0 ? (std::numeric_limits::max)() : 0} {} constexpr uint128::uint128(unsigned int v) : lo_{v}, hi_{0} {} // NOLINTNEXTLINE(runtime/int) @@ -413,13 +413,13 @@ constexpr uint128::uint128(uint64_t high, uint64_t low) : hi_{high}, lo_{low} {} constexpr uint128::uint128(int v) - : hi_{v < 0 ? std::numeric_limits::max() : 0}, + : hi_{v < 0 ? (std::numeric_limits::max)() : 0}, lo_{static_cast(v)} {} constexpr uint128::uint128(long v) // NOLINT(runtime/int) - : hi_{v < 0 ? std::numeric_limits::max() : 0}, + : hi_{v < 0 ? (std::numeric_limits::max)() : 0}, lo_{static_cast(v)} {} constexpr uint128::uint128(long long v) // NOLINT(runtime/int) - : hi_{v < 0 ? std::numeric_limits::max() : 0}, + : hi_{v < 0 ? (std::numeric_limits::max)() : 0}, lo_{static_cast(v)} {} constexpr uint128::uint128(unsigned int v) : hi_{0}, lo_{v} {} diff --git a/absl/strings/internal/numbers_test_common.h b/absl/strings/internal/numbers_test_common.h index 20e3af51..f6241ff3 100644 --- a/absl/strings/internal/numbers_test_common.h +++ b/absl/strings/internal/numbers_test_common.h @@ -64,11 +64,11 @@ struct uint32_test_case { inline const std::array& strtouint32_test_cases() { static const std::array test_cases{{ - {"0xffffffff", true, 16, std::numeric_limits::max()}, + {"0xffffffff", true, 16, (std::numeric_limits::max)()}, {"0x34234324", true, 16, 0x34234324}, {"34234324", true, 16, 0x34234324}, {"0", true, 16, 0}, - {" \t\n 0xffffffff", true, 16, std::numeric_limits::max()}, + {" \t\n 0xffffffff", true, 16, (std::numeric_limits::max)()}, {" \f\v 46", true, 10, 46}, // must accept weird whitespace {" \t\n 72717222", true, 8, 072717222}, {" \t\n 072717222", true, 8, 072717222}, @@ -77,7 +77,7 @@ inline const std::array& strtouint32_test_cases() { // Base-10 version. {"34234324", true, 0, 34234324}, - {"4294967295", true, 0, std::numeric_limits::max()}, + {"4294967295", true, 0, (std::numeric_limits::max)()}, {"34234324 \n\t", true, 10, 34234324}, // Unusual base @@ -96,8 +96,8 @@ inline const std::array& strtouint32_test_cases() { {" \t\n -123", false, 0, 0}, // Out of bounds. - {"4294967296", false, 0, std::numeric_limits::max()}, - {"0x100000000", false, 0, std::numeric_limits::max()}, + {"4294967296", false, 0, (std::numeric_limits::max)()}, + {"0x100000000", false, 0, (std::numeric_limits::max)()}, {nullptr, false, 0, 0}, }}; return test_cases; @@ -119,7 +119,7 @@ inline const std::array& strtouint64_test_cases() { {"000", true, 0, 0}, {"0", true, 0, 0}, {" \t\n 0xffffffffffffffff", true, 16, - std::numeric_limits::max()}, + (std::numeric_limits::max)()}, {"012345670123456701234", true, 8, int64_t{012345670123456701234}}, {"12345670123456701234", true, 8, int64_t{012345670123456701234}}, @@ -130,7 +130,7 @@ inline const std::array& strtouint64_test_cases() { {"34234324487834466", true, 0, int64_t{34234324487834466}}, {" \t\n 18446744073709551615", true, 0, - std::numeric_limits::max()}, + (std::numeric_limits::max)()}, {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}}, @@ -156,12 +156,13 @@ inline const std::array& strtouint64_test_cases() { // Out of bounds. {"18446744073709551616", false, 10, 0}, {"18446744073709551616", false, 0, 0}, - {"0x10000000000000000", false, 16, std::numeric_limits::max()}, + {"0x10000000000000000", false, 16, + (std::numeric_limits::max)()}, {"0X10000000000000000", false, 16, - std::numeric_limits::max()}, // 0X versus 0x. - {"0x10000000000000000", false, 0, std::numeric_limits::max()}, + (std::numeric_limits::max)()}, // 0X versus 0x. + {"0x10000000000000000", false, 0, (std::numeric_limits::max)()}, {"0X10000000000000000", false, 0, - std::numeric_limits::max()}, // 0X versus 0x. + (std::numeric_limits::max)()}, // 0X versus 0x. {"0x1234", true, 16, 0x1234}, diff --git a/absl/strings/internal/str_format/arg.h b/absl/strings/internal/str_format/arg.h index 3376d48a..ec9e6f00 100644 --- a/absl/strings/internal/str_format/arg.h +++ b/absl/strings/internal/str_format/arg.h @@ -335,12 +335,12 @@ class FormatArgImpl { using CommonType = typename std::conditional::value, int64_t, uint64_t>::type; if (static_cast(val) > - static_cast(std::numeric_limits::max())) { - return std::numeric_limits::max(); + static_cast((std::numeric_limits::max)())) { + return (std::numeric_limits::max)(); } else if (std::is_signed::value && static_cast(val) < - static_cast(std::numeric_limits::min())) { - return std::numeric_limits::min(); + static_cast((std::numeric_limits::min)())) { + return (std::numeric_limits::min)(); } return static_cast(val); } diff --git a/absl/strings/string_view.h b/absl/strings/string_view.h index 6bcd3c4e..2cc10f52 100644 --- a/absl/strings/string_view.h +++ b/absl/strings/string_view.h @@ -490,7 +490,7 @@ class string_view { private: static constexpr size_type kMaxSize = - std::numeric_limits::max(); + (std::numeric_limits::max)(); static constexpr size_type CheckLengthInternal(size_type len) { return ABSL_ASSERT(len <= kMaxSize), len; diff --git a/absl/synchronization/internal/kernel_timeout.h b/absl/synchronization/internal/kernel_timeout.h index bb708000..76e7983a 100644 --- a/absl/synchronization/internal/kernel_timeout.h +++ b/absl/synchronization/internal/kernel_timeout.h @@ -76,7 +76,7 @@ class KernelTimeout { if (x <= 0) x = 1; // A time larger than what can be represented to the kernel is treated // as no timeout. - if (x == std::numeric_limits::max()) x = 0; + if (x == (std::numeric_limits::max)()) x = 0; return x; } @@ -90,7 +90,7 @@ class KernelTimeout { ERROR, "Tried to create a timespec from a non-timeout; never do this."); // But we'll try to continue sanely. no-timeout ~= saturated timeout. - n = std::numeric_limits::max(); + n = (std::numeric_limits::max)(); } // Kernel APIs validate timespecs as being at or after the epoch, @@ -101,7 +101,7 @@ class KernelTimeout { struct timespec abstime; int64_t seconds = std::min(n / kNanosPerSecond, - int64_t{std::numeric_limits::max()}); + int64_t{(std::numeric_limits::max)()}); abstime.tv_sec = static_cast(seconds); abstime.tv_nsec = static_cast(n % kNanosPerSecond); @@ -119,7 +119,7 @@ class KernelTimeout { // and . typedef unsigned long DWord; // NOLINT DWord InMillisecondsFromNow() const { - constexpr DWord kInfinite = std::numeric_limits::max(); + constexpr DWord kInfinite = (std::numeric_limits::max)(); if (!has_timeout()) { return kInfinite; } @@ -130,7 +130,7 @@ class KernelTimeout { if (ns_ >= now) { // Round up so that Now() + ms_from_now >= ns_. constexpr uint64_t max_nanos = - std::numeric_limits::max() - 999999u; + (std::numeric_limits::max)() - 999999u; uint64_t ms_from_now = (std::min(max_nanos, ns_ - now) + 999999u) / 1000000u; if (ms_from_now > kInfinite) { diff --git a/absl/synchronization/mutex.h b/absl/synchronization/mutex.h index a3781905..aeef3c95 100644 --- a/absl/synchronization/mutex.h +++ b/absl/synchronization/mutex.h @@ -584,7 +584,7 @@ class SCOPED_LOCKABLE WriterMutexLock { // ----------------------------------------------------------------------------- // // As noted above, `Mutex` contains a number of member functions which take a -// `Condition` as a argument; clients can wait for conditions to become `true` +// `Condition` as an argument; clients can wait for conditions to become `true` // before attempting to acquire the mutex. These sections are known as // "condition critical" sections. To use a `Condition`, you simply need to // construct it, and use within an appropriate `Mutex` member function; diff --git a/absl/time/time.h b/absl/time/time.h index 7d5c3fde..e9e989cb 100644 --- a/absl/time/time.h +++ b/absl/time/time.h @@ -402,10 +402,10 @@ Duration Milliseconds(T n) { template = 0> Duration Seconds(T n) { if (n >= 0) { - if (n >= std::numeric_limits::max()) return InfiniteDuration(); + if (n >= (std::numeric_limits::max)()) return InfiniteDuration(); return time_internal::MakePosDoubleDuration(n); } else { - if (n <= std::numeric_limits::min()) return -InfiniteDuration(); + if (n <= (std::numeric_limits::min)()) return -InfiniteDuration(); return -time_internal::MakePosDoubleDuration(-n); } } @@ -686,7 +686,7 @@ constexpr Time UniversalEpoch() { // Returns an `absl::Time` that is infinitely far in the future. constexpr Time InfiniteFuture() { return Time( - time_internal::MakeDuration(std::numeric_limits::max(), ~0U)); + time_internal::MakeDuration((std::numeric_limits::max)(), ~0U)); } // InfinitePast() @@ -694,7 +694,7 @@ constexpr Time InfiniteFuture() { // Returns an `absl::Time` that is infinitely far in the past. constexpr Time InfinitePast() { return Time( - time_internal::MakeDuration(std::numeric_limits::min(), ~0U)); + time_internal::MakeDuration((std::numeric_limits::min)(), ~0U)); } // FromUnixNanos() @@ -1329,8 +1329,8 @@ constexpr bool IsInfiniteDuration(Duration d) { return GetRepLo(d) == ~0U; } // REQUIRES: IsInfiniteDuration(d) constexpr Duration OppositeInfinity(Duration d) { return GetRepHi(d) < 0 - ? MakeDuration(std::numeric_limits::max(), ~0U) - : MakeDuration(std::numeric_limits::min(), ~0U); + ? MakeDuration((std::numeric_limits::max)(), ~0U) + : MakeDuration((std::numeric_limits::min)(), ~0U); } // Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow. @@ -1355,14 +1355,14 @@ constexpr Duration FromInt64(int64_t v, std::ratio<1, N>) { v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N); } constexpr Duration FromInt64(int64_t v, std::ratio<60>) { - return (v <= std::numeric_limits::max() / 60 && - v >= std::numeric_limits::min() / 60) + return (v <= (std::numeric_limits::max)() / 60 && + v >= (std::numeric_limits::min)() / 60) ? MakeDuration(v * 60) : v > 0 ? InfiniteDuration() : -InfiniteDuration(); } constexpr Duration FromInt64(int64_t v, std::ratio<3600>) { - return (v <= std::numeric_limits::max() / 3600 && - v >= std::numeric_limits::min() / 3600) + return (v <= (std::numeric_limits::max)() / 3600 && + v >= (std::numeric_limits::min)() / 3600) ? MakeDuration(v * 3600) : v > 0 ? InfiniteDuration() : -InfiniteDuration(); } @@ -1421,8 +1421,8 @@ T ToChronoDuration(Duration d) { if (time_internal::IsInfiniteDuration(d)) return d < ZeroDuration() ? T::min() : T::max(); const auto v = ToInt64(d, Period{}); - if (v > std::numeric_limits::max()) return T::max(); - if (v < std::numeric_limits::min()) return T::min(); + if (v > (std::numeric_limits::max)()) return T::max(); + if (v < (std::numeric_limits::min)()) return T::min(); return T{v}; } @@ -1449,7 +1449,8 @@ constexpr Duration Hours(int64_t n) { constexpr bool operator<(Duration lhs, Duration rhs) { return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs) ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs) - : time_internal::GetRepHi(lhs) == std::numeric_limits::min() + : time_internal::GetRepHi(lhs) == + (std::numeric_limits::min)() ? time_internal::GetRepLo(lhs) + 1 < time_internal::GetRepLo(rhs) + 1 : time_internal::GetRepLo(lhs) < @@ -1474,7 +1475,8 @@ constexpr Duration operator-(Duration d) { // a second's worth of ticks and avoid overflow (as negating int64_t-min + 1 // is safe). return time_internal::GetRepLo(d) == 0 - ? time_internal::GetRepHi(d) == std::numeric_limits::min() + ? time_internal::GetRepHi(d) == + (std::numeric_limits::min)() ? InfiniteDuration() : time_internal::MakeDuration(-time_internal::GetRepHi(d)) : time_internal::IsInfiniteDuration(d) @@ -1487,7 +1489,8 @@ constexpr Duration operator-(Duration d) { } constexpr Duration InfiniteDuration() { - return time_internal::MakeDuration(std::numeric_limits::max(), ~0U); + return time_internal::MakeDuration((std::numeric_limits::max)(), + ~0U); } constexpr Duration FromChrono(const std::chrono::nanoseconds& d) { diff --git a/absl/types/optional.h b/absl/types/optional.h index 14210018..7677fe52 100644 --- a/absl/types/optional.h +++ b/absl/types/optional.h @@ -163,7 +163,7 @@ struct empty_struct {}; // This class stores the data in optional. // It is specialized based on whether T is trivially destructible. // This is the specialization for non trivially destructible type. -template ::value> +template ::value> class optional_data_dtor_base { struct dummy_type { static_assert(sizeof(T) % sizeof(empty_struct) == 0, ""); @@ -261,10 +261,10 @@ class optional_data_base : public optional_data_dtor_base { // have trivial move but nontrivial copy. // Also, we should be checking is_trivially_copyable here, which is not // supported now, so we use is_trivially_* traits instead. -template ::value&& - absl::is_trivially_copy_assignable< - typename std::remove_cv::type>::value&& - std::is_trivially_destructible::value> +template ::value&& + absl::is_trivially_copy_assignable::type>::value&& std::is_trivially_destructible::value> class optional_data; // Trivially copyable types -- cgit v1.2.3