[libc++] Stop using __builtin_assume in _LIBCPP_ASSERT

[ldionne]

Summary

__builtin_assume can sometimes worsen code generation. For now, the
guideline seems to be to avoid adding assumptions without a clear
optimization intent. Since _LIBCPP_ASSERT is very general, we can't
have a clear optimization intent at this level, which makes
__builtin_assume the wrong tool for the job -- at least until
__builtin_assume is changed.

See https://discourse.llvm.org/t/llvm-assume-blocks-optimization/71609
for a discussion of this.

[Mordante]

I'm a bit surprised by the information in the discourse thread; I too assumed it was safe to use.
I agree we should disable it, so LGTM!

[var-const]

FWIW, I also found the information in the thread completely counterintuitive. I guess I'll be thinking of the "assume" attribute kinda like "inline", only beneficial in certain circumstances (at least for now). But given the thread, this patch looks like the right thing to do, so LGTM.

[ldionne]

Fix [[maybe_unused]] issue on Windows.

libcxx/include/__assert

 #endif
 
 #if _LIBCPP_ENABLE_ASSERTIONS
 #  define _LIBCPP_ASSERT(expression, message)                                                                          \
     (__builtin_expect(static_cast<bool>(expression), 1)                                                                \
          ? (void)0                                                                                                     \
          : _LIBCPP_VERBOSE_ABORT(                                                                                      \
                "%s:%d: assertion %s failed: %s\n", __builtin_FILE(), __builtin_LINE(), #expression, message))
-#elif !defined(_LIBCPP_ASSERTIONS_DISABLE_ASSUME) && __has_builtin(__builtin_assume)
+// TODO: __builtin_assume can currently inhibit optimizations. Until this has been fixed and we can add
+//       assumptions without a clear optimization intent, disable that to avoid worsening the code generation.
+//       See https://discourse.llvm.org/t/llvm-assume-blocks-optimization/71609 for a discussion.
+#elif 0 && __has_builtin(__builtin_assume)
 #  define _LIBCPP_ASSERT(expression, message)                                                                          \
     (_LIBCPP_DIAGNOSTIC_PUSH _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wassume")                                              \
          __builtin_assume(static_cast<bool>(expression)) _LIBCPP_DIAGNOSTIC_POP)
 #else
 #  define _LIBCPP_ASSERT(expression, message) ((void)0)
 #endif
 
 #define _LIBCPP_ASSERT_UNCATEGORIZED(expression, message) _LIBCPP_ASSERT(expression, message)
 
 #endif // _LIBCPP___ASSERT

libcxx/src/filesystem/posix_compat.h

inline int statvfs(const wchar_t *p, StatVFS *buf) {
   buf->f_blocks = total_number_of_bytes.QuadPart;
   buf->f_bfree = total_number_of_free_bytes.QuadPart;
   buf->f_bavail = free_bytes_available_to_caller.QuadPart;
   return 0;
 }
 
 inline wchar_t *getcwd(wchar_t *buff, size_t size) { return _wgetcwd(buff, size); }
 
-inline wchar_t *realpath(const wchar_t *path, wchar_t *resolved_name) {
+inline wchar_t *realpath(const wchar_t *path, [[maybe_unused]] wchar_t *resolved_name) {
   // Only expected to be used with us allocating the buffer.
   _LIBCPP_ASSERT_UNCATEGORIZED(resolved_name == nullptr,
                  "Windows realpath() assumes a null resolved_name");
 
   WinHandle h(path, FILE_READ_ATTRIBUTES, 0);
   if (!h) {
     set_errno();
     return nullptr;