Fix implementation of ::abs and std::abs LWG 2192.

[EricWF]

Summary

All overloads of ::abs and std::abs must be present in both <cmath> and <cstdlib>. This is problematic to implement because C defines fabs in math.h and labs in stdlib.h. This introduces a circular dependency between the two headers.

This patch implements that requirement by moving abs into math.h and making stdlib.h include math.h. In order to get the underlying C declarations from the "real" stdlib.h inside our math.h we need some trickery. Specifically we need to make stdlib.h include next itself.

Suggestions for a cleaner implementation are welcome.

[mclow.lists]

I like the tests. Still looking at the code.

test/std/depr/depr.c.headers/stdlib_h.pass.cpp

92 ↗

(On Diff #193174)

same as below re: signed char and size_t

test/std/language.support/support.runtime/cstdlib.pass.cpp

67 ↗

(On Diff #193174)

How about signed char here? I don't think that there are any others we need to check.

test/std/numerics/c.math/cmath.pass.cpp

137 ↗

(On Diff #193174)

How about size_t here?

[EricWF]

Address review comments.

test/std/language.support/support.runtime/cstdlib.pass.cpp

67 ↗

(On Diff #193174)

Sure. Done.

[ldionne]

Suggestions for a cleaner implementation are welcome.

Why don't we move abs to a third header, say __abs.h, and then include that from both math.h and stdlib.h?

include/math.h

800 ↗

(On Diff #193230)

We were not using the builtin before -- why the change?

[ldionne]

Requesting change to clear up my review queue.

[mclow.lists]

include/math.h

800 ↗

(On Diff #193230)

I agree. We can't use the intrinsics here w/o a check to see if the compiler supports them.

We'll probably want to use them in the future, when SG6 plasters constexpr all over cmath, but not right now.

[ldionne]

include/math.h

800 ↗

(On Diff #193230)

I agree. We can't use the intrinsics here w/o a check to see if the compiler supports them.

Just to be clear -- this is not what I'm claiming (although you might be right), but I just wanted to understand the reason for this drive-by change.

[EricWF]

In D60097#1451656, @ldionne wrote:

Suggestions for a cleaner implementation are welcome.

Why don't we move abs to a third header, say __abs.h, and then include that from both math.h and stdlib.h?

Because __abs.h will need to #include_next both math.h and stdlib.h to get the required declarations for abs and fabs anyway.
Which means we can't avoid the _LIBCPP_STDLIB_INCLUDE_NEXT trick.

And having stdlib.h drag in the C library math.h header but not our math.h header leaves us in a worse place. For example:

#include <stdlib.h> // causes inclusion of /usr/include/math.h but not our math.h

auto x = fabs(0.0f); // calls ::fabs(double)

#include <math.h>

auto y = fabs(0.0f); // calls ::fabs(float)

So I think adding an additional header doesn't solve any of our problems.

include/math.h

800 ↗

(On Diff #193230)

I think that's a remnant from an older version of this patch.

I'll remove the __builtin_fabs stuff.

[EricWF]

• Revert use of builtins.
• Fix configuration error.

[raj.khem]

libcxx/trunk/include/stdlib.h

100

Should this be #include_next <math.h> here ? this changes causes failures when an app defines a math.h in its own sources and adds -I path to that location, any source code then having include <stdlib.h> ends up including apps math.h via system provided stdlib.h you can see this happening with gnu groff utility

[EricWF]

libcxx/trunk/include/stdlib.h

100

If I'm not mistaken, it's undefined behavior to define your own math.h and add it to the <...> include path.

And yes, this was intentional. I need to include libc++'s version of math.h to get the correct set of symbols.

[raj.khem]

libcxx/trunk/include/stdlib.h

100

if a system header is included then whatever that includes should remain within system headers search path, user is doing #include <stdlib.h>
and includes local math.h via include "math.h" not <math.h>, however the problem is clang searching for math.h requested by stdlib.h then goes into user header search paths specified via -I

[raj.khem]

libcxx/trunk/include/stdlib.h

100

to add a bit more, here I think the perceived problem is indirect inclusion of user defined header via a system header

[EricWF]

libcxx/trunk/include/stdlib.h

100

The problem is that the user is doing something they shouldn't. From the C standard

C11 7.1.2/3:
"If a file with the same name as one of the [standard headers] is placed in any of the standard places that are searched for included source files, the behavior is undefined."

[justinkb]

This change breaks compilation of firefox with clang and libc++. See https://bugzilla.mozilla.org/show_bug.cgi?id=1594027

I understand from the discussion between Raj and Eric above that that is up to mozilla developers to fix, but the problem is pretty hard to grok, so any suggestions for a fix?

libcxx/trunk/include/math.h

 */
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#define _LIBCPP_STDLIB_INCLUDE_NEXT
+#include <stdlib.h>
+
 #include_next <math.h>
 
 #ifdef __cplusplus
 
 // We support including .h headers inside 'extern "C"' contexts, so switch
 // back to C++ linkage before including these C++ headers.
 extern "C++" {
 
isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
     typedef typename std::__promote<_A1, _A2>::type type;
     return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y);
 }
 
 #endif  // isunordered
 
 // abs
 
+#undef abs
+#undef labs
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+#undef llabs
+#endif
+
+// MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
+#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
+inline _LIBCPP_INLINE_VISIBILITY long abs(long __x) _NOEXCEPT {
+  return ::labs(__x);
+}
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {
+  return ::llabs(__x);
+}
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+#endif // !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
+
+
 #if !(defined(_AIX) || defined(__sun__))
-inline _LIBCPP_INLINE_VISIBILITY
-float
-abs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);}
+inline _LIBCPP_INLINE_VISIBILITY float abs(float __lcpp_x) _NOEXCEPT {
+  return ::fabsf(__lcpp_x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY
-double
-abs(double __lcpp_x) _NOEXCEPT {return ::fabs(__lcpp_x);}
+inline _LIBCPP_INLINE_VISIBILITY double abs(double __lcpp_x) _NOEXCEPT {
+  return ::fabs(__lcpp_x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY
-long double
-abs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
+inline _LIBCPP_INLINE_VISIBILITY long double
+abs(long double __lcpp_x) _NOEXCEPT {
+  return ::fabsl(__lcpp_x);
+}
 #endif // !(defined(_AIX) || defined(__sun__))
 
+// div
+
+#undef div
+#undef ldiv
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+#undef lldiv
+#endif
+
+// MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
+#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
+inline _LIBCPP_INLINE_VISIBILITY ldiv_t div(long __x, long __y) _NOEXCEPT {
+  return ::ldiv(__x, __y);
+}
+#ifndef _LIBCPP_HAS_NO_LONG_LONG
+inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x,
+                                             long long __y) _NOEXCEPT {
+  return ::lldiv(__x, __y);
+}
+#endif // _LIBCPP_HAS_NO_LONG_LONG
+#endif // _LIBCPP_MSVCRT / __sun__ / _AIX
+
 // acos
 
 #if !(defined(_AIX) || defined(__sun__))
 inline _LIBCPP_INLINE_VISIBILITY float       acos(float __lcpp_x) _NOEXCEPT       {return ::acosf(__lcpp_x);}
 inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);}
 #endif
 
 template <class _A1>

libcxx/trunk/include/stdlib.h

 // -*- C++ -*-
 //===--------------------------- stdlib.h ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#if defined(__need_malloc_and_calloc)
+#if defined(__need_malloc_and_calloc) || defined(_LIBCPP_STDLIB_INCLUDE_NEXT)
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_STDLIB_INCLUDE_NEXT)
+#undef _LIBCPP_STDLIB_INCLUDE_NEXT
+#endif
+
 #include_next <stdlib.h>
 
 #elif !defined(_LIBCPP_STDLIB_H)
 #define _LIBCPP_STDLIB_H
 
 /*
     stdlib.h synopsis
 

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #include_next <stdlib.h>
 
 #ifdef __cplusplus
-
-extern "C++" {
-
-#undef abs
-#undef div
-#undef labs
-#undef ldiv
-#ifndef _LIBCPP_HAS_NO_LONG_LONG
-#undef llabs
-#undef lldiv
-#endif
-
-// MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
-#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
-inline _LIBCPP_INLINE_VISIBILITY long      abs(     long __x) _NOEXCEPT {return  labs(__x);}
-#ifndef _LIBCPP_HAS_NO_LONG_LONG
-inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {return llabs(__x);}
-#endif // _LIBCPP_HAS_NO_LONG_LONG
-
-inline _LIBCPP_INLINE_VISIBILITY  ldiv_t div(     long __x,      long __y) _NOEXCEPT {return  ldiv(__x, __y);}
-#ifndef _LIBCPP_HAS_NO_LONG_LONG
-inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x, long long __y) _NOEXCEPT {return lldiv(__x, __y);}
-#endif // _LIBCPP_HAS_NO_LONG_LONG
-#endif // _LIBCPP_MSVCRT / __sun__ / _AIX
-
-}  // extern "C++"
-
+#include <math.h>
 #endif  // __cplusplus
 
 #endif  // _LIBCPP_STDLIB_H

libcxx/trunk/test/std/depr/depr.c.headers/math_h.pass.cpp

 Ambiguous remquo(Ambiguous, Ambiguous, int*){ return Ambiguous(); }
 Ambiguous rint(Ambiguous){ return Ambiguous(); }
 Ambiguous round(Ambiguous){ return Ambiguous(); }
 Ambiguous scalbln(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous scalbn(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous tgamma(Ambiguous){ return Ambiguous(); }
 Ambiguous trunc(Ambiguous){ return Ambiguous(); }
 
+template <class T, class = decltype(::abs(std::declval<T>()))>
+std::true_type has_abs_imp(int);
+template <class T>
+std::false_type has_abs_imp(...);
+
+template <class T>
+struct has_abs : decltype(has_abs_imp<T>(0)) {};
+
 void test_abs()
 {
-    static_assert((std::is_same<decltype(abs((float)0)), float>::value), "");
-    static_assert((std::is_same<decltype(abs((double)0)), double>::value), "");
-    static_assert((std::is_same<decltype(abs((long double)0)), long double>::value), "");
-    static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value), "");
-    assert(abs(-1.) == 1);
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wabsolute-value"
+#endif
+  static_assert(
+      (std::is_same<decltype(abs((long double)0)), long double>::value), "");
+  static_assert((std::is_same<decltype(abs((int)0)), int>::value), "");
+  static_assert((std::is_same<decltype(abs((long)0)), long>::value), "");
+  static_assert((std::is_same<decltype(abs((long long)0)), long long>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((unsigned char)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((unsigned short)0)), int>::value),
+                "");
+
+  static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value),
+                "");
+
+  static_assert(!has_abs<unsigned>::value, "");
+  static_assert(!has_abs<unsigned long>::value, "");
+  static_assert(!has_abs<unsigned long long>::value, "");
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
 }
 
 void test_acos()
 {
     static_assert((std::is_same<decltype(acos((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(acos((bool)0)), double>::value), "");
     static_assert((std::is_same<decltype(acos((unsigned short)0)), double>::value), "");
     static_assert((std::is_same<decltype(acos((int)0)), double>::value), "");

libcxx/trunk/test/std/depr/depr.c.headers/stdlib_h.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // test <stdlib.h>
 
 #include <stdlib.h>
 #include <type_traits>
+#include <cassert>
 
 #include "test_macros.h"
 
 // As of 1/10/2015 clang emits a -Wnonnull warnings even if the warning occurs
 // in an unevaluated context. For this reason we manually suppress the warning.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wnonnull"
 #endif

 #ifndef NULL
 #error NULL not defined
 #endif
 
 #ifndef RAND_MAX
 #error RAND_MAX not defined
 #endif
 
+template <class T, class = decltype(::abs(std::declval<T>()))>
+std::true_type has_abs_imp(int);
+template <class T>
+std::false_type has_abs_imp(...);
+
+template <class T>
+struct has_abs : decltype(has_abs_imp<T>(0)) {};
+
+void test_abs() {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wabsolute-value"
+#endif
+  static_assert((std::is_same<decltype(abs((float)0)), float>::value), "");
+  static_assert((std::is_same<decltype(abs((double)0)), double>::value), "");
+  static_assert(
+      (std::is_same<decltype(abs((long double)0)), long double>::value), "");
+  static_assert((std::is_same<decltype(abs((int)0)), int>::value), "");
+  static_assert((std::is_same<decltype(abs((long)0)), long>::value), "");
+  static_assert((std::is_same<decltype(abs((long long)0)), long long>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((unsigned char)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((unsigned short)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((signed char)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((short)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((unsigned char)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(abs((char)0)), int>::value),
+                "");
+
+  static_assert(!has_abs<unsigned>::value, "");
+  static_assert(!has_abs<unsigned long>::value, "");
+  static_assert(!has_abs<unsigned long long>::value, "");
+  static_assert(!has_abs<size_t>::value, "");
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+  assert(abs(-1.) == 1);
+}
+
 int main(int, char**)
 {
     size_t s = 0; ((void)s);
     div_t d; ((void)d);
     ldiv_t ld; ((void)ld);
     lldiv_t lld; ((void)lld);
     char** endptr = 0;
     static_assert((std::is_same<decltype(atof("")), double>::value), "");
#endif
     const wchar_t* pwc = 0;
     char* pc = 0;
     static_assert((std::is_same<decltype(mblen("",0)), int>::value), "");
     static_assert((std::is_same<decltype(mbtowc(pw,"",0)), int>::value), "");
     static_assert((std::is_same<decltype(wctomb(pc,L' ')), int>::value), "");
     static_assert((std::is_same<decltype(mbstowcs(pw,"",0)), size_t>::value), "");
     static_assert((std::is_same<decltype(wcstombs(pc,pwc,0)), size_t>::value), "");
 
+    test_abs();
+
     return 0;
 }

libcxx/trunk/test/std/language.support/support.runtime/cstdlib.pass.cpp

 void test_div_struct() {
     TestType obj;
     static_assert(sizeof(obj) >= sizeof(IntType) * 2, ""); // >= to account for alignment.
     static_assert((std::is_same<decltype(obj.quot), IntType>::value), "");
     static_assert((std::is_same<decltype(obj.rem), IntType>::value), "");
     ((void) obj);
 };
 
+template <class T, class = decltype(std::abs(std::declval<T>()))>
+std::true_type has_abs_imp(int);
+template <class T>
+std::false_type has_abs_imp(...);
+
+template <class T>
+struct has_abs : decltype(has_abs_imp<T>(0)) {};
+
+void test_abs() {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wabsolute-value"
+#endif
+    static_assert((std::is_same<decltype(std::abs((float)0)), float>::value), "");
+    static_assert((std::is_same<decltype(std::abs((double)0)), double>::value), "");
+    static_assert(
+        (std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::abs((int)0)), int>::value), "");
+    static_assert((std::is_same<decltype(std::abs((long)0)), long>::value), "");
+    static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value),
+                  "");
+    static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value),
+                  "");
+    static_assert((std::is_same<decltype(std::abs((unsigned short)0)), int>::value),
+                  "");
+    static_assert((std::is_same<decltype(std::abs((signed char)0)), int>::value),
+                  "");
+    static_assert((std::is_same<decltype(std::abs((short)0)), int>::value),
+                  "");
+    static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value),
+                  "");
+    static_assert((std::is_same<decltype(std::abs((char)0)), int>::value),
+                  "");
+
+    static_assert(!has_abs<unsigned>::value, "");
+    static_assert(!has_abs<unsigned long>::value, "");
+    static_assert(!has_abs<unsigned long long>::value, "");
+    static_assert(!has_abs<size_t>::value, "");
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+    assert(std::abs(-1.) == 1);
+}
+
 int main(int, char**)
 {
     std::size_t s = 0;
     ((void)s);
     static_assert((std::is_same<std::size_t, decltype(sizeof(int))>::value), "");
     test_div_struct<std::div_t, int>();
     test_div_struct<std::ldiv_t, long>();
     test_div_struct<std::lldiv_t, long long>();
#endif
     const wchar_t* pwc = 0;
     char* pc = 0;
     static_assert((std::is_same<decltype(std::mblen("",0)), int>::value), "");
     static_assert((std::is_same<decltype(std::mbtowc(pw,"",0)), int>::value), "");
     static_assert((std::is_same<decltype(std::wctomb(pc,L' ')), int>::value), "");
     static_assert((std::is_same<decltype(std::mbstowcs(pw,"",0)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstombs(pc,pwc,0)), std::size_t>::value), "");
 
+    test_abs();
+
     return 0;
 }

libcxx/trunk/test/std/numerics/c.math/cmath.pass.cpp

 Ambiguous remquo(Ambiguous, Ambiguous, int*){ return Ambiguous(); }
 Ambiguous rint(Ambiguous){ return Ambiguous(); }
 Ambiguous round(Ambiguous){ return Ambiguous(); }
 Ambiguous scalbln(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous scalbn(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous tgamma(Ambiguous){ return Ambiguous(); }
 Ambiguous trunc(Ambiguous){ return Ambiguous(); }
 
-void test_abs()
-{
-    static_assert((std::is_same<decltype(std::abs((float)0)), float>::value), "");
-    static_assert((std::is_same<decltype(std::abs((double)0)), double>::value), "");
-    static_assert((std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
-    static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value), "");
-    assert(std::abs(-1.) == 1);
+template <class T, class = decltype(std::abs(std::declval<T>()))>
+std::true_type has_abs_imp(int);
+template <class T>
+std::false_type has_abs_imp(...);
+
+template <class T>
+struct has_abs : decltype(has_abs_imp<T>(0)) {};
+
+void test_abs() {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wabsolute-value"
+#endif
+  static_assert(
+      (std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
+  static_assert((std::is_same<decltype(std::abs((int)0)), int>::value), "");
+  static_assert((std::is_same<decltype(std::abs((long)0)), long>::value), "");
+  static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value),
+                "");
+  static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(std::abs((unsigned short)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(std::abs((signed char)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(std::abs((short)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value),
+                "");
+  static_assert((std::is_same<decltype(std::abs((char)0)), int>::value),
+                "");
+
+  static_assert(!has_abs<unsigned>::value, "");
+  static_assert(!has_abs<unsigned long>::value, "");
+  static_assert(!has_abs<unsigned long long>::value, "");
+  static_assert(!has_abs<size_t>::value, "");
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
 }
 
+
 void test_acos()
 {
     static_assert((std::is_same<decltype(std::acos((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::acos((bool)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acos((unsigned short)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acos((int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acos((unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acos((long)0)), double>::value), "");

libcxx/trunk/www/cxx1z_status.html

<!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <tr><td><a href="https://wg21.link/LWG2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td>Complete</td></tr>
    <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2192">2192</a></td><td>Validity and return type of <tt>std::abs(0u)</tt> is unclear</td><td>Jacksonville</td><td></td></tr>
+  <tr><td><a href="https://wg21.link/LWG2192">2192</a></td><td>Validity and return type of <tt>std::abs(0u)</tt> is unclear</td><td>Jacksonville</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2276">2276</a></td><td>Missing requirement on <tt>std::promise::set_exception</tt></td><td>Jacksonville</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2296">2296</a></td><td><tt>std::addressof</tt> should be <tt>constexpr</td><td>Jacksonville</td><td>Complete (Clang Only)</td></tr>
   <tr><td><a href="https://wg21.link/LWG2450">2450</a></td><td><tt>(greater|less|greater_equal|less_equal)&lt;void&gt;</tt> do not yield a total order for pointers</td><td>Jacksonville</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2520">2520</a></td><td>N4089 broke initializing <tt>unique_ptr&lt;T[]&gt;</tt> from a <tt>nullptr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2522">2522</a></td><td>[fund.ts.v2] Contradiction in <tt>set_default_resource</tt> specification</td><td>Jacksonville</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2523">2523</a></td><td><tt>std::promise</tt> synopsis shows two <tt>set_value_at_thread_exit()</tt>'s for no apparent reason</td><td>Jacksonville</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2537">2537</a></td><td>Constructors for <code>priority_queue</code> taking allocators should call <code>make_heap</code></td><td>Jacksonville</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2539">2539</a></td><td>[fund.ts.v2] <tt>invocation_trait</tt> definition definition doesn't work for surrogate call functions</td><td>Jacksonville</td><td></td></tr>