libc++: Print log/error messages on stderr, not stdout

[ed]

Summary

There are a couple of places where libc++ prints log/error messages to stdout on its own. This may of course interfere with the output generated with applications. Log/error messages should be directed to stderr instead.

[mclow.lists]

You missed one in <string> (line 42)

[ed]

In D8135#136153, @mclow.lists wrote:

You missed one in <string> (line 42)

Ah, thanks for noticing. Updated the diff.

libcxx/trunk/include/__debug

 #pragma GCC system_header
 #endif
 
 #if _LIBCPP_DEBUG_LEVEL >= 1
 #   include <cstdlib>
 #   include <cstdio>
 #   include <cstddef>
 #   ifndef _LIBCPP_ASSERT
-#      define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::printf("%s\n", m), _VSTD::abort()))
+#      define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::fprintf(stderr, "%s\n", m), _VSTD::abort()))
 #   endif
 #endif
 
 #ifndef _LIBCPP_ASSERT
 #   define _LIBCPP_ASSERT(x, m) ((void)0)
 #endif
 
 #if _LIBCPP_DEBUG_LEVEL >= 2

libcxx/trunk/src/exception.cpp

 terminate() _NOEXCEPT
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         (*get_terminate())();
         // handler should not return
-        printf("terminate_handler unexpectedly returned\n");
+        fprintf(stderr, "terminate_handler unexpectedly returned\n");
         ::abort();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
-        printf("terminate_handler unexpectedly threw an exception\n");
+        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
         ::abort();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 #endif // !__EMSCRIPTEN__
 #endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
 
 #if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__)
 bool uncaught_exception() _NOEXCEPT
 {
 #if defined(__APPLE__) || defined(_LIBCPPABI_VERSION)
     // on Darwin, there is a helper function so __cxa_get_globals is private
     return __cxa_uncaught_exception();
 #else  // __APPLE__
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING("uncaught_exception not yet implemented")
 #   else
 #       warning uncaught_exception not yet implemented
 #   endif
-    printf("uncaught_exception not yet implemented\n");
+    fprintf(stderr, "uncaught_exception not yet implemented\n");
     ::abort();
 #endif  // __APPLE__
 }
 
 
 #ifndef _LIBCPPABI_VERSION
 
 exception::~exception() _NOEXCEPT

 #elif defined(__GLIBCXX__)
     reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
 #else
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
-    printf("exception_ptr not yet implemented\n");
+    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__)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
-    printf("exception_ptr not yet implemented\n");
+    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__)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
-    printf("exception_ptr not yet implemented\n");
+    fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 
 nested_exception::nested_exception() _NOEXCEPT
     : __ptr_(current_exception())
 {
 }
#if HAVE_DEPENDENT_EH_ABI
     ptr.__ptr_ = __cxa_current_primary_exception();
     return ptr;
 #else
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING( "exception_ptr not yet implemented" )
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
-    printf("exception_ptr not yet implemented\n");
+    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__)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
-    printf("exception_ptr not yet implemented\n");
+    fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 } // std

libcxx/trunk/src/string.cpp

 
 template<typename T>
 inline
 void throw_helper( const string& msg )
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw T( msg );
 #else
-    printf("%s\n", msg.c_str());
+    fprintf(stderr, "%s\n", msg.c_str());
     abort();
 #endif
 }
 
 inline
 void throw_from_string_out_of_range( const string& func )
 {
     throw_helper<out_of_range>(func + ": out of range");