Make the presence of stdin and stdout optional

[ed]

Summary

The idea behind Nuxi CloudABI is that it is targeted at (but not limited to) running networked services in a sandboxed environment. The model behind stdin, stdout and stderr is strongly focused on interactive tools in a command shell. CloudABI does not support the notion of stdin and stdout, as 'standard input/output' does not apply to services. The concept of stderr does makes sense though, as services do need some mechanism to log error messages in a uniform way.

This patch extends libc++ in such a way that std::cin and std::cout and the associated <cstdio>/<cwchar> functions can be disabled through the flags _LIBCPP_HAS_NO_STDIN and _LIBCPP_HAS_NO_STDOUT, respectively. At the same time it attempts to clean up src/iostream.cpp a bit. Instead of using a single array of mbstate_t objects and hardcoding the array indices, it creates separate objects that declared next to the iostream objects and their buffers. The code is also restructured by interleaving the construction and setup of c* and wc* objects. That way it is more obvious that this is done identically.

The c* and wc* objects already have separate unit tests. Make use of this fact by adding XFAILs in case libcpp-has-no-std* is set. That way the tests work in both directions. If stdin or stdout is disabled, these tests will therefore test for the absence of c* and wc*.

My promise is that this will be the last intrusive patch to add support for CloudABI. ;-)

[jroelofs]

At the same time it attempts to clean up src/iostream.cpp

Mind separating this into two logical patches?

[ed]

In D8340#140927, @jroelofs wrote:

At the same time it attempts to clean up src/iostream.cpp

Mind separating this into two logical patches?

No problem at all! I've just sent out the following code review:

http://reviews.llvm.org/D8342

[jroelofs]

This part looks OK.

Is there any value in gating the stdout & stdin bits separately?

test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp

1 ↗

(On Diff #21983)

Wow, this test is confusing now. I'm not sure how to make that better.

[ed]

In D8340#140949, @jroelofs wrote:

This part looks OK.

Is there any value in gating the stdout & stdin bits separately?

The main reason I went for this approach was because I felt that placing it behind one knob would raise the question: "What's so special about these two? Why is stderr treated separately? Why not disable stdin and stderr, or stdout and stderr?" The patch demonstrates that apart from the tying, stdin, stdout and stderr are separate.

That said, I wouldn't mind merging this, as long as we can get a nice compromise between getting the code to work on CloudABI while keeping it readable. Thoughts?

[jroelofs]

Ok, keeping them separate sounds reasonable to me. LGTM.

[EricWF]

The LIT stuff looks good to me. I haven't reviewed the changes to the library though.

include/__config

735–741 ↗

(On Diff #21987)

What I like about _LIBCPP_HAS_NO_MONOTONIC_CLOCK and _LIBCPP_HAS_NO_THREADS is that they must be explicitly defined be the user. We don't automatically provide those configurations by way of the __config header. I like this because those flags make libc++ become a non-conforming standard library.

Along the same vein I'm not sure I like __config having configuration paths that make libc++ non-conforming. I understand why this is done in the case of __CloudABI__ and I'm not objecting. I just want to air my uneasiness.

test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp

19 ↗

(On Diff #21987)

Unrelated to this patch but these tests need to be looked into. They seem fishy.

test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp

18 ↗

(On Diff #21987)

There is something fishy about this test already.

[jroelofs]

include/__config

735–741 ↗

(On Diff #21987)

What I like about _LIBCPP_HAS_NO_MONOTONIC_CLOCK and _LIBCPP_HAS_NO_THREADS is that they must be explicitly defined be the user.

I can see the reasoning behind it, but this is really inconvenient for me. The problem is that it's not reasonable to expect my users to #define these things, so locally I added a <__config_site> that #defines _LIBCPP_HAS_NO_MONOTONIC_CLOCK and _LIBCPP_HAS_NO_THREADS, which is #included at the top of <__config>.

I didn't realize this before, but I think the best way forward here would be to have cmake generate the <__config_site>, and stick it in an include dir in the build directory. Then at install time, have it copy that file to the install dir. This would have the added benefit of making the -D_LIBCPP_HAS_NO_THREADS=1 things in config.py go away.

How does that sound, @EricWF?

test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp

18 ↗

(On Diff #21987)

Indeed... this part is begging to be an ShTest test.

[EricWF]

include/__config

735–741 ↗

(On Diff #21987)

I like the idea of that but I'm not sure it helps fix this problem per se since it still allows for implicit non-conforming configurations (although I greatly sympathize with the rational for it) I would want to run it by @mclow.lists first. I've thought about this before and my main concern is that it would make reproducing bugs a lot more difficult because every user has a different <__config_site> header.

Perhaps we allow for a <__config_site> header to be used, but we only ever provide an empty one with a big comment at the top warning users about modifying it. Then if somebody really needs one of these configurations they can go take the time to manually fill it out with the required definitions. This would make it trickier to use the header in a regular build/test workflow though.

[jroelofs]

include/__config

735–741 ↗

(On Diff #21987)

This would be something that is completely generated from the cmake configure line. I don't think it would change the repro steps at all because we'd already have to know what their configure line was.

The added benefit here is that it would keep a record on the end user's system of what flags their libc++ library was built with.

[mclow.lists]

Does it make sense to have separate switches for stdin and stdout, as opposed to just "the standard streams"?

Or does CloudABI support stderr?

include/__config

735–741 ↗

(On Diff #21987)

That sounds promising.

Like @ErikWF, I am leery of making it convenient for users to (inadvertently, easily) build non-conforming versions of libc++ - for no reason other than the support questions/bug reports that filter back to us.

[mclow.lists]

Ok, I see that @jroelofs already raised that issue.
Read the conversation too fast - sorry.

[ed]

In D8340#142113, @mclow.lists wrote:

Or does CloudABI support stderr?

Yes, only stderr. For a service, stdin and stdout make little sense, whereas stderr can still be used for logging. For example, assert() will log its diagnostics to stderr.

[jroelofs]

include/__config

735–741 ↗

(On Diff #21987)

We could add cmake message(WARNING "Disabling FOO makes libc++ a non-conforming library") when those get turned on, and also leave a note in the generated __config_site file saying roughly the same thing. That way the person building the library gets a warning that maybe they should re-consider what they're doing, and their end-user gets an easy answer for why there aren't any FOO symbols/declarations in the library/headers.

libcxx/trunk/CMakeLists.txt

 option(LIBCXX_ENABLE_EXCEPTIONS "Use exceptions." ON)
 option(LIBCXX_ENABLE_RTTI "Use run time type information." ON)
 option(LIBCXX_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
 option(LIBCXX_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LIBCXX_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 option(LIBCXX_ENABLE_CXX1Y "Enable -std=c++1y and use of c++1y language features if the compiler supports it." OFF)
 option(LIBCXX_ENABLE_SHARED "Build libc++ as a shared library." ON)
 option(LIBCXX_ENABLE_GLOBAL_FILESYSTEM_NAMESPACE "Build libc++ with support for the global filesystem namespace." ON)
+option(LIBCXX_ENABLE_STDIN "Build libc++ with support for stdin/std::cin." ON)
+option(LIBCXX_ENABLE_STDOUT "Build libc++ with support for stdout/std::cout." ON)
 option(LIBCXX_ENABLE_THREADS "Build libc++ with support for threads." ON)
 option(LIBCXX_BUILD_32_BITS "Build 32 bit libc++" OFF)
 option(LIBCXX_ENABLE_MONOTONIC_CLOCK
   "Build libc++ with support for a monotonic clock.
    This option may only be used when LIBCXX_ENABLE_THREADS=OFF." ON)
 option(LIBCXX_INSTALL_HEADERS "Install the libc++ headers." ON)
 option(LIBCXX_INSTALL_SUPPORT_HEADERS "Install libc++ support headers." ON)
 option(LIBCXX_ENABLE_STATIC_ABI_LIBRARY "Statically link the ABI library" OFF)
if (MSVC)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 # LIBCXX_ENABLE_GLOBAL_FILESYSTEM_NAMESPACE configuration
 if (NOT LIBCXX_ENABLE_GLOBAL_FILESYSTEM_NAMESPACE)
   add_definitions(-D_LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE)
 endif()
 
+# LIBCXX_ENABLE_STDIN configuration
+if (NOT LIBCXX_ENABLE_STDIN)
+  add_definitions(-D_LIBCPP_HAS_NO_STDIN)
+endif()
+
+# LIBCXX_ENABLE_STDOUT configuration
+if (NOT LIBCXX_ENABLE_STDOUT)
+  add_definitions(-D_LIBCPP_HAS_NO_STDOUT)
+endif()
+
 # LIBCXX_ENABLE_THREADS configuration
 if (NOT LIBCXX_ENABLE_THREADS)
   add_definitions(-D_LIBCPP_HAS_NO_THREADS)
   if (NOT LIBCXX_ENABLE_MONOTONIC_CLOCK)
     add_definitions(-D_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
   endif()
 # Ensure LIBCXX_ENABLE_MONOTONIC_CLOCK is set to ON.
 elseif(NOT LIBCXX_ENABLE_MONOTONIC_CLOCK)

libcxx/trunk/include/__config

 // Systems that use capability-based security (FreeBSD with Capsicum,
 // Nuxi CloudABI) may only provide local filesystem access (using *at()).
 // Functions like open(), rename(), unlink() and stat() should not be
 // used, as they attempt to access the global filesystem namespace.
 #ifdef __CloudABI__
 #define _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
 #endif
 
+// CloudABI is intended for running networked services. Processes do not
+// have standard input and output channels.
+#ifdef __CloudABI__
+#define _LIBCPP_HAS_NO_STDIN
+#define _LIBCPP_HAS_NO_STDOUT
+#endif
+
 #if defined(__ANDROID__) || defined(__CloudABI__)
 #define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 #endif
 
 #endif  // _LIBCPP_CONFIG

libcxx/trunk/include/cstdio

 #endif  // ferror
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::FILE;
 using ::fpos_t;
 using ::size_t;
 
-#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
-using ::remove;
-using ::rename;
-using ::tmpfile;
-using ::tmpnam;
-#endif
 using ::fclose;
 using ::fflush;
-#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
-using ::fopen;
-using ::freopen;
-#endif
 using ::setbuf;
 using ::setvbuf;
 using ::fprintf;
 using ::fscanf;
-using ::printf;
-using ::scanf;
 using ::snprintf;
 using ::sprintf;
 using ::sscanf;
 #ifndef _LIBCPP_MSVCRT
 using ::vfprintf;
 using ::vfscanf;
-using ::vscanf;
 using ::vsscanf;
 #endif // _LIBCPP_MSVCRT
-using ::vprintf;
 using ::vsnprintf;
 using ::vsprintf;
 using ::fgetc;
 using ::fgets;
 using ::fputc;
 using ::fputs;
 using ::getc;
-using ::getchar;
-#if _LIBCPP_STD_VER <= 11
-using ::gets;
-#endif
 using ::putc;
-using ::putchar;
-using ::puts;
 using ::ungetc;
 using ::fread;
 using ::fwrite;
 using ::fgetpos;
 using ::fseek;
 using ::fsetpos;
 using ::ftell;
 using ::rewind;
 using ::clearerr;
 using ::feof;
 using ::ferror;
 using ::perror;
 
+#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+using ::fopen;
+using ::freopen;
+using ::remove;
+using ::rename;
+using ::tmpfile;
+using ::tmpnam;
+#endif
+
+#ifndef _LIBCPP_HAS_NO_STDIN
+using ::getchar;
+#if _LIBCPP_STD_VER <= 11
+using ::gets;
+#endif
+using ::scanf;
+using ::vscanf;
+#endif
+
+#ifndef _LIBCPP_HAS_NO_STDOUT
+using ::printf;
+using ::putchar;
+using ::puts;
+using ::vprintf;
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTDIO

libcxx/trunk/include/cwchar

 using ::tm;
 using ::wint_t;
 using ::FILE;
 using ::fwprintf;
 using ::fwscanf;
 using ::swprintf;
 using ::vfwprintf;
 using ::vswprintf;
-using ::vwprintf;
 #ifndef _LIBCPP_MSVCRT
 using ::swscanf;
 using ::vfwscanf;
 using ::vswscanf;
-using ::vwscanf;
 #endif // _LIBCPP_MSVCRT
-using ::wprintf;
-using ::wscanf;
 using ::fgetwc;
 using ::fgetws;
 using ::fputwc;
 using ::fputws;
 using ::fwide;
 using ::getwc;
-using ::getwchar;
 using ::putwc;
-using ::putwchar;
 using ::ungetwc;
 using ::wcstod;
 #ifndef _LIBCPP_MSVCRT
 using ::wcstof;
 using ::wcstold;
 #endif // _LIBCPP_MSVCRT
 using ::wcstol;
 #ifndef _LIBCPP_HAS_NO_LONG_LONG

 using ::wctob;
 using ::mbsinit;
 using ::mbrlen;
 using ::mbrtowc;
 using ::wcrtomb;
 using ::mbsrtowcs;
 using ::wcsrtombs;
 
+#ifndef _LIBCPP_HAS_NO_STDIN
+using ::getwchar;
+#ifndef _LIBCPP_MSVCRT
+using ::vwscanf;
+#endif // _LIBCPP_MSVCRT
+using ::wscanf;
+#endif
+
+#ifndef _LIBCPP_HAS_NO_STDOUT
+using ::putwchar;
+using ::vwprintf;
+using ::wprintf;
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CWCHAR

libcxx/trunk/include/iostream

 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_HAS_NO_STDIN
 extern _LIBCPP_FUNC_VIS istream cin;
-extern _LIBCPP_FUNC_VIS ostream cout;
-extern _LIBCPP_FUNC_VIS ostream cerr;
-extern _LIBCPP_FUNC_VIS ostream clog;
 extern _LIBCPP_FUNC_VIS wistream wcin;
+#endif
+#ifndef _LIBCPP_HAS_NO_STDOUT
+extern _LIBCPP_FUNC_VIS ostream cout;
 extern _LIBCPP_FUNC_VIS wostream wcout;
+#endif
+extern _LIBCPP_FUNC_VIS ostream cerr;
 extern _LIBCPP_FUNC_VIS wostream wcerr;
+extern _LIBCPP_FUNC_VIS ostream clog;
 extern _LIBCPP_FUNC_VIS wostream wclog;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_IOSTREAM

libcxx/trunk/src/iostream.cpp

 //===------------------------ iostream.cpp --------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "__std_stream"
 #include "string"
 #include "new"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_HAS_NO_STDIN
 _ALIGNAS_TYPE (istream)  _LIBCPP_FUNC_VIS char cin [sizeof(istream)];
 _ALIGNAS_TYPE (__stdinbuf<char> ) static char __cin [sizeof(__stdinbuf <char>)];
 static mbstate_t mb_cin;
 _ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin [sizeof(wistream)];
 _ALIGNAS_TYPE (__stdinbuf<wchar_t> ) static char __wcin [sizeof(__stdinbuf <wchar_t>)];
 static mbstate_t mb_wcin;
+#endif
 
+#ifndef _LIBCPP_HAS_NO_STDOUT
 _ALIGNAS_TYPE (ostream)  _LIBCPP_FUNC_VIS char cout[sizeof(ostream)];
 _ALIGNAS_TYPE (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)];
 static mbstate_t mb_cout;
 _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)];
 _ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
 static mbstate_t mb_wcout;
+#endif
 
 _ALIGNAS_TYPE (ostream)  _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)];
 _ALIGNAS_TYPE (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)];
 static mbstate_t mb_cerr;
 _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)];
 _ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
 static mbstate_t mb_wcerr;
 
 _ALIGNAS_TYPE (ostream)  _LIBCPP_FUNC_VIS char clog[sizeof(ostream)];
 _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)];
 
 ios_base::Init __start_std_streams;
 
 ios_base::Init::Init()
 {
+#ifndef _LIBCPP_HAS_NO_STDIN
     istream* cin_ptr  = ::new(cin)  istream(::new(__cin)  __stdinbuf <char>(stdin, &mb_cin));
     wistream* wcin_ptr  = ::new(wcin)  wistream(::new(__wcin)  __stdinbuf <wchar_t>(stdin, &mb_wcin));
+#endif
+#ifndef _LIBCPP_HAS_NO_STDOUT
     ostream* cout_ptr = ::new(cout) ostream(::new(__cout) __stdoutbuf<char>(stdout, &mb_cout));
     wostream* wcout_ptr = ::new(wcout) wostream(::new(__wcout) __stdoutbuf<wchar_t>(stdout, &mb_wcout));
+#endif
     ostream* cerr_ptr = ::new(cerr) ostream(::new(__cerr) __stdoutbuf<char>(stderr, &mb_cerr));
                         ::new(clog) ostream(cerr_ptr->rdbuf());
     wostream* wcerr_ptr = ::new(wcerr) wostream(::new(__wcerr) __stdoutbuf<wchar_t>(stderr, &mb_wcerr));
                           ::new(wclog) wostream(wcerr_ptr->rdbuf());
 
+#if !defined(_LIBCPP_HAS_NO_STDIN) && !defined(_LIBCPP_HAS_NO_STDOUT)
     cin_ptr->tie(cout_ptr);
     wcin_ptr->tie(wcout_ptr);
+#endif
     _VSTD::unitbuf(*cerr_ptr);
     _VSTD::unitbuf(*wcerr_ptr);
+#ifndef _LIBCPP_HAS_NO_STDOUT
     cerr_ptr->tie(cout_ptr);
     wcerr_ptr->tie(wcout_ptr);
+#endif
 }
 
 ios_base::Init::~Init()
 {
+#ifndef _LIBCPP_HAS_NO_STDOUT
     ostream* cout_ptr = reinterpret_cast<ostream*>(cout);
     wostream* wcout_ptr = reinterpret_cast<wostream*>(wcout);
     cout_ptr->flush();
     wcout_ptr->flush();
+#endif
 
     ostream* clog_ptr = reinterpret_cast<ostream*>(clog);
     wostream* wclog_ptr = reinterpret_cast<wostream*>(wclog);
     clog_ptr->flush();
     wclog_ptr->flush();
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/trunk/test/CMakeLists.txt

if (LIT_EXECUTABLE)
   set(LIBCXX_LIT_VARIANT "libcxx" CACHE STRING
       "Configuration variant to use for LIT.")
 
   pythonize_bool(LIBCXX_ENABLE_EXCEPTIONS)
   pythonize_bool(LIBCXX_ENABLE_RTTI)
   pythonize_bool(LIBCXX_ENABLE_SHARED)
   pythonize_bool(LIBCXX_BUILD_32_BITS)
   pythonize_bool(LIBCXX_ENABLE_GLOBAL_FILESYSTEM_NAMESPACE)
+  pythonize_bool(LIBCXX_ENABLE_STDIN)
+  pythonize_bool(LIBCXX_ENABLE_STDOUT)
   pythonize_bool(LIBCXX_ENABLE_THREADS)
   pythonize_bool(LIBCXX_ENABLE_MONOTONIC_CLOCK)
   # The tests shouldn't link to any ABI library when it has been linked into
   # libc++ statically.
   if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY)
     set(LIBCXX_CXX_ABI_LIBNAME "none")
   endif()
   set(LIBCXX_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING

libcxx/trunk/test/libcxx/test/config.py

def configure_default_compile_flags(self):
         if self.target_info.platform() == 'linux':
             self.cxx.compile_flags += ['-D__STDC_FORMAT_MACROS',
                                        '-D__STDC_LIMIT_MACROS',
                                        '-D__STDC_CONSTANT_MACROS']
         # Configure feature flags.
         self.configure_compile_flags_exceptions()
         self.configure_compile_flags_rtti()
         self.configure_compile_flags_no_global_filesystem_namespace()
+        self.configure_compile_flags_no_stdin()
+        self.configure_compile_flags_no_stdout()
         enable_32bit = self.get_lit_bool('enable_32bit', False)
         if enable_32bit:
             self.cxx.flags += ['-m32']
         # Configure threading features.
         enable_threads = self.get_lit_bool('enable_threads', True)
         enable_monotonic_clock = self.get_lit_bool('enable_monotonic_clock',
                                                    True)
         if not enable_threads:
def configure_compile_flags_no_global_filesystem_namespace(self):
         enable_global_filesystem_namespace = self.get_lit_bool(
             'enable_global_filesystem_namespace', True)
         if not enable_global_filesystem_namespace:
             self.config.available_features.add(
                 'libcpp-has-no-global-filesystem-namespace')
             self.cxx.compile_flags += [
                 '-D_LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE']
 
+    def configure_compile_flags_no_stdin(self):
+        enable_stdin = self.get_lit_bool('enable_stdin', True)
+        if not enable_stdin:
+            self.config.available_features.add('libcpp-has-no-stdin')
+            self.cxx.compile_flags += ['-D_LIBCPP_HAS_NO_STDIN']
+
+    def configure_compile_flags_no_stdout(self):
+        enable_stdout = self.get_lit_bool('enable_stdout', True)
+        if not enable_stdout:
+            self.config.available_features.add('libcpp-has-no-stdout')
+            self.cxx.compile_flags += ['-D_LIBCPP_HAS_NO_STDOUT']
+
     def configure_compile_flags_no_threads(self):
         self.cxx.compile_flags += ['-D_LIBCPP_HAS_NO_THREADS']
         self.config.available_features.add('libcpp-has-no-threads')
 
     def configure_compile_flags_no_monotonic_clock(self):
         self.cxx.compile_flags += ['-D_LIBCPP_HAS_NO_MONOTONIC_CLOCK']
         self.config.available_features.add('libcpp-has-no-monotonic-clock')
 

libcxx/trunk/test/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 config.cxx_under_test           = "@LIBCXX_COMPILER@"
 config.std                      = "@LIBCXX_STD_VERSION@"
 config.libcxx_src_root          = "@LIBCXX_SOURCE_DIR@"
 config.libcxx_obj_root          = "@LIBCXX_BINARY_DIR@"
 config.cxx_library_root         = "@LIBCXX_LIBRARY_DIR@"
 config.enable_exceptions        = "@LIBCXX_ENABLE_EXCEPTIONS@"
 config.enable_rtti              = "@LIBCXX_ENABLE_RTTI@"
 config.enable_shared            = "@LIBCXX_ENABLE_SHARED@"
 config.enable_32bit             = "@LIBCXX_BUILD_32_BITS@"
 config.enable_global_filesystem_namespace = "@LIBCXX_ENABLE_GLOBAL_FILESYSTEM_NAMESPACE@"
+config.enable_stdin             = "@LIBCXX_ENABLE_STDIN@"
+config.enable_stdout            = "@LIBCXX_ENABLE_STDOUT@"
 config.enable_threads           = "@LIBCXX_ENABLE_THREADS@"
 config.enable_monotonic_clock   = "@LIBCXX_ENABLE_MONOTONIC_CLOCK@"
 config.cxx_abi                  = "@LIBCXX_CXX_ABI_LIBNAME@"
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.abi_library_path         = "@LIBCXX_CXX_ABI_LIBRARY_PATH@"
 config.configuration_variant    = "@LIBCXX_LIT_VARIANT@"
 config.target_triple            = "@LIBCXX_TARGET_TRIPLE@"
 config.sysroot                  = "@LIBCXX_SYSROOT@"
 config.gcc_toolchain            = "@LIBCXX_GCC_TOOLCHAIN@"
 config.target_info              = "@LIBCXX_TARGET_INFO@"
 config.executor                 = "@LIBCXX_EXECUTOR@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXX_SOURCE_DIR@/test/lit.cfg")

libcxx/trunk/test/std/input.output/file.streams/c.files/cstdio.pass.cpp

 
 int main()
 {
     std::FILE* fp = 0;
     std::fpos_t fpos = {0};
     std::size_t s = 0;
     char* cp = 0;
     std::va_list va;
-#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
-    static_assert((std::is_same<decltype(std::remove("")), int>::value), "");
-    static_assert((std::is_same<decltype(std::rename("","")), int>::value), "");
-    static_assert((std::is_same<decltype(std::tmpfile()), std::FILE*>::value), "");
-    static_assert((std::is_same<decltype(std::tmpnam(cp)), char*>::value), "");
-#endif
     static_assert((std::is_same<decltype(std::fclose(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::fflush(fp)), int>::value), "");
-#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
-    static_assert((std::is_same<decltype(std::fopen("", "")), std::FILE*>::value), "");
-    static_assert((std::is_same<decltype(std::freopen("", "", fp)), std::FILE*>::value), "");
-#endif
     static_assert((std::is_same<decltype(std::setbuf(fp,cp)), void>::value), "");
     static_assert((std::is_same<decltype(std::vfprintf(fp,"",va)), int>::value), "");
     static_assert((std::is_same<decltype(std::fprintf(fp," ")), int>::value), "");
     static_assert((std::is_same<decltype(std::fscanf(fp,"")), int>::value), "");
-    static_assert((std::is_same<decltype(std::printf(" ")), int>::value), "");
-    static_assert((std::is_same<decltype(std::scanf(" ")), int>::value), "");
     static_assert((std::is_same<decltype(std::snprintf(cp,0," ")), int>::value), "");
     static_assert((std::is_same<decltype(std::sprintf(cp," ")), int>::value), "");
     static_assert((std::is_same<decltype(std::sscanf("","")), int>::value), "");
     static_assert((std::is_same<decltype(std::vfprintf(fp,"",va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vfscanf(fp,"",va)), int>::value), "");
-    static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), "");
-    static_assert((std::is_same<decltype(std::vscanf("",va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vsnprintf(cp,0," ",va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vsprintf(cp," ",va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vsscanf("","",va)), int>::value), "");
     static_assert((std::is_same<decltype(std::fgetc(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::fgets(cp,0,fp)), char*>::value), "");
     static_assert((std::is_same<decltype(std::fputc(0,fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::fputs("",fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::getc(fp)), int>::value), "");
-    static_assert((std::is_same<decltype(std::getchar()), int>::value), "");
-#if _LIBCPP_STD_VER <= 11
-    static_assert((std::is_same<decltype(std::gets(cp)), char*>::value), "");
-#endif
     static_assert((std::is_same<decltype(std::putc(0,fp)), int>::value), "");
-    static_assert((std::is_same<decltype(std::putchar(0)), int>::value), "");
-    static_assert((std::is_same<decltype(std::puts("")), int>::value), "");
     static_assert((std::is_same<decltype(std::ungetc(0,fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::fread((void*)0,0,0,fp)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::fwrite((const void*)0,0,0,fp)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::fgetpos(fp, &fpos)), int>::value), "");
     static_assert((std::is_same<decltype(std::fseek(fp, 0,0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fsetpos(fp, &fpos)), int>::value), "");
     static_assert((std::is_same<decltype(std::ftell(fp)), long>::value), "");
     static_assert((std::is_same<decltype(std::rewind(fp)), void>::value), "");
     static_assert((std::is_same<decltype(std::clearerr(fp)), void>::value), "");
     static_assert((std::is_same<decltype(std::feof(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::ferror(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::perror("")), void>::value), "");
+
+#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+    static_assert((std::is_same<decltype(std::fopen("", "")), std::FILE*>::value), "");
+    static_assert((std::is_same<decltype(std::freopen("", "", fp)), std::FILE*>::value), "");
+    static_assert((std::is_same<decltype(std::remove("")), int>::value), "");
+    static_assert((std::is_same<decltype(std::rename("","")), int>::value), "");
+    static_assert((std::is_same<decltype(std::tmpfile()), std::FILE*>::value), "");
+    static_assert((std::is_same<decltype(std::tmpnam(cp)), char*>::value), "");
+#endif
+
+#ifndef _LIBCPP_HAS_NO_STDIN
+    static_assert((std::is_same<decltype(std::getchar()), int>::value), "");
+#if _LIBCPP_STD_VER <= 11
+    static_assert((std::is_same<decltype(std::gets(cp)), char*>::value), "");
+#endif
+    static_assert((std::is_same<decltype(std::scanf(" ")), int>::value), "");
+    static_assert((std::is_same<decltype(std::vscanf("",va)), int>::value), "");
+#endif
+
+#ifndef _LIBCPP_HAS_NO_STDOUT
+    static_assert((std::is_same<decltype(std::printf(" ")), int>::value), "");
+    static_assert((std::is_same<decltype(std::putchar(0)), int>::value), "");
+    static_assert((std::is_same<decltype(std::puts("")), int>::value), "");
+    static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), "");
+#endif
 }

libcxx/trunk/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp

 #include <iostream>
 #include <cassert>
 
 int main()
 {
 #if 0
     std::cerr << "Hello World!\n";
 #else
+#ifdef _LIBCPP_HAS_NO_STDOUT
+    assert(std::cerr.tie() == NULL);
+#else
     assert(std::cerr.tie() == &std::cout);
+#endif
     assert(std::cerr.flags() & std::ios_base::unitbuf);
 #endif  // 0
 }

libcxx/trunk/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-has-no-stdin
+
 // <iostream>
 
 // istream cin;
 
 #include <iostream>
 #include <cassert>
 
 int main()
 {
 #if 0
     std::cout << "Hello World!\n";
     int i;
     std::cout << "Enter a number: ";
     std::cin >> i;
     std::cout << "The number is : " << i << '\n';
 #else  // 0
+#ifdef _LIBCPP_HAS_NO_STDOUT
+    assert(std::cin.tie() == NULL);
+#else
     assert(std::cin.tie() == &std::cout);
 #endif
+#endif
 }

libcxx/trunk/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-has-no-stdout
+
 // <iostream>
 
 // istream cout;
 
 #include <iostream>
 
 int main()
 {

libcxx/trunk/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp

 #include <iostream>
 #include <cassert>
 
 int main()
 {
 #if 0
     std::wcerr << L"Hello World!\n";
 #else
+#ifdef _LIBCPP_HAS_NO_STDOUT
+    assert(std::wcerr.tie() == NULL);
+#else
     assert(std::wcerr.tie() == &std::wcout);
+#endif
     assert(std::wcerr.flags() & std::ios_base::unitbuf);
 #endif  // 0
 }

libcxx/trunk/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-has-no-stdin
+
 // <iostream>
 
 // istream wcin;
 
 #include <iostream>
 #include <cassert>
 
 int main()
 {
 #if 0
     std::wcout << L"Hello World!\n";
     int i;
     std::wcout << L"Enter a number: ";
     std::wcin >> i;
     std::wcout << L"The number is : " << i << L'\n';
 #else  // 0
+#ifdef _LIBCPP_HAS_NO_STDOUT
+    assert(std::wcin.tie() == NULL);
+#else
     assert(std::wcin.tie() == &std::wcout);
 #endif
+#endif
 }

libcxx/trunk/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-has-no-stdout
+
 // <iostream>
 
 // istream wcout;
 
 #include <iostream>
 
 int main()
 {
 #if 0
     std::wcout << L"Hello World!\n";
 #else
     (void)std::wcout;
 #endif
 }

libcxx/trunk/test/std/strings/c.strings/cwchar.pass.cpp

#endif
     static_assert((std::is_same<decltype(std::fwprintf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::fwscanf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::swprintf(ws, s, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::swscanf(L"", L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::vfwprintf(fp, L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vfwscanf(fp, L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vswprintf(ws, s, L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vswscanf(L"", L"", va)), int>::value), "");
-    static_assert((std::is_same<decltype(std::vwprintf(L"", va)), int>::value), "");
-    static_assert((std::is_same<decltype(std::vwscanf(L"", va)), int>::value), "");
-    static_assert((std::is_same<decltype(std::wprintf(L"")), int>::value), "");
-    static_assert((std::is_same<decltype(std::wscanf(L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::fgetwc(fp)), std::wint_t>::value), "");
     static_assert((std::is_same<decltype(std::fgetws(ws, 0, fp)), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::fputwc(L' ', fp)), std::wint_t>::value), "");
     static_assert((std::is_same<decltype(std::fputws(L"", fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::fwide(fp, 0)), int>::value), "");
     static_assert((std::is_same<decltype(std::getwc(fp)), std::wint_t>::value), "");
-    static_assert((std::is_same<decltype(std::getwchar()), std::wint_t>::value), "");
     static_assert((std::is_same<decltype(std::putwc(L' ', fp)), std::wint_t>::value), "");
-    static_assert((std::is_same<decltype(std::putwchar(L' ')), std::wint_t>::value), "");
     static_assert((std::is_same<decltype(std::ungetwc(L' ', fp)), std::wint_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstod(L"", (wchar_t**)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::wcstof(L"", (wchar_t**)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::wcstold(L"", (wchar_t**)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::wcstol(L"", (wchar_t**)0, 0)), long>::value), "");
     static_assert((std::is_same<decltype(std::wcstoll(L"", (wchar_t**)0, 0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), "");
     static_assert((std::is_same<decltype(std::wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), "");
#endif
     static_assert((std::is_same<decltype(std::btowc(0)), wint_t>::value), "");
     static_assert((std::is_same<decltype(std::wctob(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::mbsinit(&mb)), int>::value), "");
     static_assert((std::is_same<decltype(std::mbrlen("", s, &mb)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::mbrtowc(ws, "", s, &mb)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::wcrtomb(ns, L' ', &mb)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::mbsrtowcs(ws, (const char**)0, s, &mb)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::wcsrtombs(ns, (const wchar_t**)0, s, &mb)), std::size_t>::value), "");
+
+#ifndef _LIBCPP_HAS_NO_STDIN
+    static_assert((std::is_same<decltype(std::getwchar()), std::wint_t>::value), "");
+    static_assert((std::is_same<decltype(std::vwscanf(L"", va)), int>::value), "");
+    static_assert((std::is_same<decltype(std::wscanf(L"")), int>::value), "");
+#endif
+
+#ifndef _LIBCPP_HAS_NO_STDOUT
+    static_assert((std::is_same<decltype(std::putwchar(L' ')), std::wint_t>::value), "");
+    static_assert((std::is_same<decltype(std::vwprintf(L"", va)), int>::value), "");
+    static_assert((std::is_same<decltype(std::wprintf(L"")), int>::value), "");
+#endif
 }