[libcxx] Resolve warnings for Wshift-sign-overflow

[ddcc]

Summary

These warning were identified while debugging modules with Wsystem-headers.

[philnik]

Thanks! LGTM with green CI.

libcxx/include/__chrono/duration.h

215

That's a very complex way to write numeric_limits<intmax_t>::max().

[Mordante]

libcxx/include/__chrono/duration.h

215

This is a private field is there a reason not to use an __ugly name?
@philnik shouldn't clang-tidy have spotted this?

[philnik]

libcxx/include/__chrono/duration.h

215

I think clang-tidy currently only checks parameters and private non-static members. I'm sure there is a configuration for readability-identifier-naming for this case. I'll check that when the simpler cases are checked. (BTW readability- is a complete misnomer for our purposes).

[Mordante]

libcxx/include/__chrono/duration.h

215

Ah that explains it. I thought it did all privates.

(BTW readability- is a complete misnomer for our purposes).

:-D good luck filing a bug report ;-)

215

I think clang-tidy currently only checks parameters and private non-static members. I'm sure there is a configuration for readability-identifier-naming for this case. I'll check that when the simpler cases are checked. (BTW readability- is a complete misnomer for our purposes).

[ddcc]

Hmm apparently there's some CUDA builder failures, so I've reverted for now.

https://lab.llvm.org/buildbot#builders/1/builds/33677
https://lab.llvm.org/buildbot#builders/55/builds/33820
https://lab.llvm.org/buildbot#builders/46/builds/33687

/ssd/cuda-k80-0/work/clang-cuda-k80/clang/bin/../include/c++/v1/ratio:143:33: error: in-class initializer for static data member is not a constant expression
   static const intmax_t min = numeric_limits<intmax_t>::min() + 1;

Do these computations need to be marked constexpr? I think the underlying one in numeric_limit is already _LIBCPP_CONSTEXPR.

[philnik]

@ddcc Please ensure that the pre-commit CI is green before landing. This failure will probably get catched there.

libcxx/include/__chrono/duration.h

class _LIBCPP_TEMPLATE_VIS duration
     {
     private:
         static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
         static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
         static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
         static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
         static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
         static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
-        static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
+        static const intmax_t max = numeric_limits<intmax_t>::max();
 
         template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
         struct __mul    // __overflow == false
         {
             static const intmax_t value = _Xp * _Yp;
         };
 
         template <intmax_t _Xp, intmax_t _Yp>

libcxx/include/__memory/temporary_buffer.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_TEMPORARY_BUFFER_H
 #define _LIBCPP___MEMORY_TEMPORARY_BUFFER_H
 
 #include <__config>
 #include <__type_traits/alignment_of.h>
 #include <__utility/pair.h>
 #include <cstddef>
+#include <limits>
 #include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _LIBCPP_DEPRECATED_IN_CXX17
 pair<_Tp*, ptrdiff_t>
 get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
 {
     pair<_Tp*, ptrdiff_t> __r(0, 0);
-    const ptrdiff_t __m = (~ptrdiff_t(0) ^
-                           ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1)))
-                           / sizeof(_Tp);
+    const ptrdiff_t __m = (~ptrdiff_t(0) ^ numeric_limits<ptrdiff_t>::min()) / sizeof(_Tp);
     if (__n > __m)
         __n = __m;
     while (__n > 0)
     {
 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
     if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp)))
         {
             align_val_t __al =

libcxx/include/ratio

template <class R1, class R2> inline constexpr bool ratio_greater_v
     = ratio_greater<R1, R2>::value;                                     // C++17
   template <class R1, class R2> inline constexpr bool ratio_greater_equal_v
     = ratio_greater_equal<R1, R2>::value;                               // C++17
 }
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <climits>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

 };
 
 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
 class __ll_add;
 
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_add<_Xp, _Yp, 1>
 {
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+    static const intmax_t min = numeric_limits<intmax_t>::min() + 1;
+    static const intmax_t max = numeric_limits<intmax_t>::max();
 
     static_assert(_Xp <= max - _Yp, "overflow in __ll_add");
 public:
     static const intmax_t value = _Xp + _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_add<_Xp, _Yp, 0>
 {
 public:
     static const intmax_t value = _Xp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_add<_Xp, _Yp, -1>
 {
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+    static const intmax_t min = numeric_limits<intmax_t>::min() + 1;
+    static const intmax_t max = numeric_limits<intmax_t>::max();
 
     static_assert(min - _Yp <= _Xp, "overflow in __ll_add");
 public:
     static const intmax_t value = _Xp + _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
 class __ll_sub;
 
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_sub<_Xp, _Yp, 1>
 {
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+    static const intmax_t min = numeric_limits<intmax_t>::min() + 1;
+    static const intmax_t max = numeric_limits<intmax_t>::max();
 
     static_assert(min + _Yp <= _Xp, "overflow in __ll_sub");
 public:
     static const intmax_t value = _Xp - _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_sub<_Xp, _Yp, 0>
 {
 public:
     static const intmax_t value = _Xp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_sub<_Xp, _Yp, -1>
 {
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+    static const intmax_t min = numeric_limits<intmax_t>::min() + 1;
+    static const intmax_t max = numeric_limits<intmax_t>::max();
 
     static_assert(_Xp <= max + _Yp, "overflow in __ll_sub");
 public:
     static const intmax_t value = _Xp - _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_mul
 {
-    static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
-    static const intmax_t min = nan + 1;
-    static const intmax_t max = -min;
+    static const intmax_t nan = numeric_limits<intmax_t>::min();
+    static const intmax_t min = numeric_limits<intmax_t>::min() + 1;
+    static const intmax_t max = numeric_limits<intmax_t>::max();
     static const intmax_t __a_x = __static_abs<_Xp>::value;
     static const intmax_t __a_y = __static_abs<_Yp>::value;
 
     static_assert(_Xp != nan && _Yp != nan && __a_x <= max / __a_y, "overflow in __ll_mul");
 public:
     static const intmax_t value = _Xp * _Yp;
 };
 

 public:
     static const intmax_t value = 0;
 };
 
 // Not actually used but left here in case needed in future maintenance
 template <intmax_t _Xp, intmax_t _Yp>
 class __ll_div
 {
-    static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
-    static const intmax_t min = nan + 1;
-    static const intmax_t max = -min;
+    static const intmax_t nan = numeric_limits<intmax_t>::min();
+    static const intmax_t min = numeric_limits<intmax_t>::min() + 1;
+    static const intmax_t max = numeric_limits<intmax_t>::max();
 
     static_assert(_Xp != nan && _Yp != nan && _Yp != 0, "overflow in __ll_div");
 public:
     static const intmax_t value = _Xp / _Yp;
 };
 
 template <intmax_t _Num, intmax_t _Den = 1>
 class _LIBCPP_TEMPLATE_VIS ratio

libcxx/utils/libcxx/test/params.py

 from libcxx.test.features import _isMSVC
 import re
 
 _warningFlags = [
   '-Werror',
   '-Wall',
   '-Wextra',
   '-Wshadow',
+  '-Wshift-sign-overflow',
   '-Wundef',
   '-Wno-unused-command-line-argument',
   '-Wno-attributes',
   '-Wno-pessimizing-move',
   '-Wno-c++11-extensions',
   '-Wno-noexcept-type',
   '-Wno-aligned-allocation-unavailable',
   '-Wno-atomic-alignment',