Refer to _LIBCPP_MSVC macro where applicable

[kastiglione]

Summary

Replace preprocess conditions of defined(_MSC_VER) && !defined(__clang__) with
defined(_LIBCPP_MSVC).

No functional change.

[EricWF]

LGTM. Although Ironically we can no longer support MSVC due to our use of #include_next which MSVC doesn't support.

utils/google-benchmark/include/benchmark/macros.h

28 ↗

(On Diff #83396)

Please don't patch this file. It isn't actually part of libc++. It's just an import of Google Benchmark.

[kastiglione]

Revert change to Google Benchmark

[compnerd]

SVN r294171

include/__config

 
 // Try to find out if RTTI is disabled.
 // g++ and cl.exe have RTTI on by default and define a macro when it is.
 // g++ only defines the macro in 4.3.2 and onwards.
 #if !defined(_LIBCPP_NO_RTTI)
 #  if defined(__GNUC__) && ((__GNUC__ >= 5) || (__GNUC__ == 4 && \
    (__GNUC_MINOR__ >= 3 || __GNUC_PATCHLEVEL__ >= 2))) && !defined(__GXX_RTTI)
 #    define _LIBCPP_NO_RTTI
-#  elif (defined(_MSC_VER) && !defined(__clang__)) && !defined(_CPPRTTI)
+#  elif defined(_LIBCPP_MSVC) && !defined(_CPPRTTI)
 #    define _LIBCPP_NO_RTTI
 #  endif
 #endif
 
 #ifndef _LIBCPP_WEAK
 #  define _LIBCPP_WEAK __attribute__((__weak__))
 #endif
 

include/__undef___deallocate

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifdef __deallocate
 #if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
-#if defined(_MSC_VER) && !defined(__clang__)
+#if defined(_LIBCPP_MSVC)
 _LIBCPP_WARNING("macro __deallocate is incompatible with C++.  #undefining __deallocate")
 #else
 #warning: macro __deallocate is incompatible with C++.  #undefining __deallocate
 #endif
 #endif
 #undef __deallocate
 #endif

include/__undef_min_max

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifdef min
 #if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
-#if defined(_MSC_VER) && ! defined(__clang__)
+#if defined(_LIBCPP_MSVC)
 _LIBCPP_WARNING("macro min is incompatible with C++.  Try #define NOMINMAX "
                 "before any Windows header. #undefing min")
 #else
 #warning: macro min is incompatible with C++.  #undefing min
 #endif
 #endif
 #undef min
 #endif
 
 #ifdef max
 #if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
-#if defined(_MSC_VER) && ! defined(__clang__)
+#if defined(_LIBCPP_MSVC)
 _LIBCPP_WARNING("macro max is incompatible with C++.  Try #define NOMINMAX "
                 "before any Windows header. #undefing max")
 #else
 #warning: macro max is incompatible with C++.  #undefing max
 #endif
 #endif
 #undef max
 #endif

include/ext/hash_map

 #include <__config>
 #include <__hash_table>
 #include <functional>
 #include <stdexcept>
 #include <type_traits>
 #include <ext/__hash>
 
 #if __DEPRECATED
-#if defined(_MSC_VER) && ! defined(__clang__)
+#if defined(_LIBCPP_MSVC)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
 #else
 #   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
 #endif
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/ext/hash_set

 */
 
 #include <__config>
 #include <__hash_table>
 #include <functional>
 #include <ext/__hash>
 
 #if __DEPRECATED
-#if defined(_MSC_VER) && ! defined(__clang__)
+#if defined(_LIBCPP_MSVC)
     _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
 #else
 #   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
 #endif
 #endif
 
 namespace __gnu_cxx {
 

src/exception.cpp

#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && \
     (defined(__APPLE__) || defined(_LIBCPPABI_VERSION))
    // on Darwin, there is a helper function so __cxa_get_globals is private
 # if _LIBCPPABI_VERSION > 1101
     return __cxa_uncaught_exceptions();
 # else
     return __cxa_uncaught_exception() ? 1 : 0;
 # endif
 #else  // __APPLE__
-#   if defined(_MSC_VER) && ! defined(__clang__)
+#   if defined(_LIBCPP_MSVC)
         _LIBCPP_WARNING("uncaught_exceptions not yet implemented")
 #   else
 #       warning uncaught_exception not yet implemented
 #   endif
     fprintf(stderr, "uncaught_exceptions not yet implemented\n");
     ::abort();
 #endif  // __APPLE__
 }

 
 exception_ptr::~exception_ptr() _NOEXCEPT
 {
 #if HAVE_DEPENDENT_EH_ABI
     __cxa_decrement_exception_refcount(__ptr_);
 #elif defined(__GLIBCXX__)
     reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
 #else
-#   if defined(_MSC_VER) && ! defined(__clang__)
+#   if defined(_LIBCPP_MSVC)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 
 exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
     : __ptr_(other.__ptr_)
 {
 #if HAVE_DEPENDENT_EH_ABI
     __cxa_increment_exception_refcount(__ptr_);
 #elif defined(__GLIBCXX__)
     new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
         reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
 #else
-#   if defined(_MSC_VER) && ! defined(__clang__)
+#   if defined(_LIBCPP_MSVC)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 
 exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
 {
 #if HAVE_DEPENDENT_EH_ABI
     if (__ptr_ != other.__ptr_)
     {
         __cxa_increment_exception_refcount(other.__ptr_);
         __cxa_decrement_exception_refcount(__ptr_);
         __ptr_ = other.__ptr_;
     }
     return *this;
 #elif defined(__GLIBCXX__)
     *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
         reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
     return *this;
 #else
-#   if defined(_MSC_VER) && ! defined(__clang__)
+#   if defined(_LIBCPP_MSVC)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }

 #if HAVE_DEPENDENT_EH_ABI
     // be nicer if there was a constructor that took a ptr, then
     // this whole function would be just:
     //    return exception_ptr(__cxa_current_primary_exception());
     exception_ptr ptr;
     ptr.__ptr_ = __cxa_current_primary_exception();
     return ptr;
 #else
-#   if defined(_MSC_VER) && ! defined(__clang__)
+#   if defined(_LIBCPP_MSVC)
         _LIBCPP_WARNING( "exception_ptr not yet implemented" )
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 
 #endif  // !__GLIBCXX__
 
 _LIBCPP_NORETURN
 void rethrow_exception(exception_ptr p)
 {
 #if HAVE_DEPENDENT_EH_ABI
     __cxa_rethrow_primary_exception(p.__ptr_);
     // if p.__ptr_ is NULL, above returns so we terminate
     terminate();
 #elif defined(__GLIBCXX__)
     rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
 #else
-#   if defined(_MSC_VER) && ! defined(__clang__)
+#   if defined(_LIBCPP_MSVC)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 } // std

src/include/atomic_support.h

#if defined(__clang__) && __has_builtin(__atomic_load_n)             \
                        && defined(__ATOMIC_ACQ_REL)                  \
                        && defined(__ATOMIC_SEQ_CST)
 #   define _LIBCPP_HAS_ATOMIC_BUILTINS
 #elif !defined(__clang__) && defined(_GNUC_VER) && _GNUC_VER >= 407
 #   define _LIBCPP_HAS_ATOMIC_BUILTINS
 #endif
 
 #if !defined(_LIBCPP_HAS_ATOMIC_BUILTINS) && !defined(_LIBCPP_HAS_NO_THREADS)
-# if defined(_MSC_VER) && !defined(__clang__)
+# if defined(_LIBCPP_MSVC)
     _LIBCPP_WARNING("Building libc++ without __atomic builtins is unsupported")
 # else
 #   warning Building libc++ without __atomic builtins is unsupported
 # endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

src/thread.cpp

#elif defined(_SC_NPROCESSORS_ONLN)
     return static_cast<unsigned>(result);
 #elif defined(_LIBCPP_WIN32API)
     SYSTEM_INFO info;
     GetSystemInfo(&info);
     return info.dwNumberOfProcessors;
 #else  // defined(CTL_HW) && defined(HW_NCPU)
     // TODO: grovel through /proc or check cpuid on x86 and similar
     // instructions on other architectures.
-#   if defined(_MSC_VER) && ! defined(__clang__)
+#   if defined(_LIBCPP_MSVC)
         _LIBCPP_WARNING("hardware_concurrency not yet implemented")
 #   else
 #       warning hardware_concurrency not yet implemented
 #   endif
     return 0;  // Means not computable [thread.thread.static]
 #endif  // defined(CTL_HW) && defined(HW_NCPU)
 }