libc++: Make support for thread-unsafe C functions optional

[ed]

Summary

One of the aspects of CloudABI is that it aims to help you write code that is thread-safe out of the box. This is very important if you want to write libraries that are easy to reuse. For CloudABI we decided to not provide the thread-unsafe functions. So far this is working out pretty well, as thread-unsafety issues are detected really early on.

The following patch adds a knob to libc++, _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS, that can be set to disable thread-unsafe functions that can easily be avoided in practice. The following functions are not thread-safe:

• <clocale>: locale handles should be preferred over setlocale().
• <cstdlib>: mbrlen(), mbrtowc() and wcrtomb() should be preferred over their non-restartable counterparts.
• <ctime>: asctime(), ctime(), gmtime() and localtime() are not thread-safe. The first two are also deprecated by POSIX.

[EricWF]

The CMake and LIT stuff LGTM. However I would rather keep the directory structure in test/std the same as the structure of the C++ standard clauses. Could you rename the fail tests, put them in the correct directories and use // REQUIRES: libcpp-has-no-thread-unsafe-c-functions?

[ed]

In D8703#148896, @EricWF wrote:

The CMake and LIT stuff LGTM. However I would rather keep the directory structure in test/std the same as the structure of the C++ standard clauses. Could you rename the fail tests, put them in the correct directories and use // REQUIRES: libcpp-has-no-thread-unsafe-c-functions?

Sure! Just to make sure I understand it correctly: in this specific case, the tests should be called:

test/std/utilities/date.time/asctime.fail.cpp
test/std/utilities/date.time/ctime.fail.cpp
test/std/utilities/date.time/gmtime.fail.cpp
test/std/utilities/date.time/localtime.fail.cpp

As in, the same as they are right now, but without the no.thread.unsafe.c.functions component in between?

[EricWF]

In D8703#149021, @ed wrote:

In D8703#148896, @EricWF wrote:

The CMake and LIT stuff LGTM. However I would rather keep the directory structure in test/std the same as the structure of the C++ standard clauses. Could you rename the fail tests, put them in the correct directories and use // REQUIRES: libcpp-has-no-thread-unsafe-c-functions?

Sure! Just to make sure I understand it correctly: in this specific case, the tests should be called:

test/std/utilities/date.time/asctime.fail.cpp
test/std/utilities/date.time/ctime.fail.cpp
test/std/utilities/date.time/gmtime.fail.cpp
test/std/utilities/date.time/localtime.fail.cpp

As in, the same as they are right now, but without the no.thread.unsafe.c.functions component in between?

Pretty much, but I would make the test names more descriptive so they infer that these are failure tests for when we have no unsafe C functions. The test names don't *have* to follow the standard names.

[ed]

In D8703#149206, @EricWF wrote:

Pretty much, but I would make the test names more descriptive so they infer that these are failure tests for when we have no unsafe C functions. The test names don't *have* to follow the standard names.

Got it. What do you think about the following naming scheme? I've named them ${function}.thread-unsafe.fail.cpp.

[ed]

Friendly ping. Does this patch look all right to land? Thanks!

[jroelofs]

I'm deferring to @mclow.lists on this one.

[mclow.lists]

Except for the bit in locale.cpp, these changes look OK to me.

I'm concerned about the proliferation of "subsets" of the libc++ functionality (no threads, no filesystem, no thread-unsafe fns), but ...

src/locale.cpp

579 ↗

(On Diff #22955)

Unlike all the other changes, this is a behavior change.

[ed]

In D8703#192868, @mclow.lists wrote:

Except for the bit in locale.cpp, these changes look OK to me.

Thanks for the review!

Regarding the change to locale.cpp: CloudABI does not have setlocale(), which is why this call would need to be disabled. libc++ still has a global locale, but it's not the case that this is propagated to the C runtime.

I've reverted this part of the change for now, as we could argue it's not related to the change at hand. I suspect it may make more sense to #ifndef __CloudABI__ that part at one point.

libcxx/trunk/CMakeLists.txt

 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_ENABLE_THREAD_UNSAFE_C_FUNCTIONS "Build libc++ with support for thread-unsafe C functions" 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_GENERATE_COVERAGE "Enable generating code coverage." OFF)
 set(LIBCXX_COVERAGE_LIBRARY "" CACHE STRING
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)
   message(FATAL_ERROR "LIBCXX_ENABLE_MONOTONIC_CLOCK can only be set to OFF"
                       " when LIBCXX_ENABLE_THREADS is also set to OFF.")
 endif()
 
+# LIBCXX_ENABLE_THREAD_UNSAFE_C_FUNCTIONS configuration
+if (NOT LIBCXX_ENABLE_THREAD_UNSAFE_C_FUNCTIONS)
+  add_definitions(-D_LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS)
+endif()
+
 # Configure for sanitizers. If LIBCXX_BUILT_STANDALONE then we have to do
 # the flag translation ourselves. Othewise LLVM's CMakeList.txt will handle it.
 if (LIBCXX_BUILT_STANDALONE)
   # NOTE: LLVM_USE_SANITIZER checks for a UNIX like system instead of MSVC.
   # But we don't have LLVM_ON_UNIX so checking for MSVC is the best we can do.
   if (LLVM_USE_SANITIZER AND NOT MSVC)
     append_if(LIBCXX_CXX_FLAGS LIBCXX_HAS_FNO_OMIT_FRAME_POINTER_FLAG
               "-fno-omit-frame-pointer")

libcxx/trunk/include/__config

 #define _LIBCPP_HAS_NO_STDIN
 #define _LIBCPP_HAS_NO_STDOUT
 #endif
 
 #if defined(__ANDROID__) || defined(__CloudABI__)
 #define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 #endif
 
+// Thread-unsafe functions such as strtok(), mbtowc() and localtime()
+// are not available.
+#ifdef __CloudABI__
+#define _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
+#endif
+
 #endif  // _LIBCPP_CONFIG

libcxx/trunk/include/clocale

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::lconv;
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 using ::setlocale;
+#endif
 using ::localeconv;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CLOCALE

libcxx/trunk/include/cstdlib

 #undef div
 using ::div;
 #undef ldiv
 using ::ldiv;
 #ifndef _LIBCPP_HAS_NO_LONG_LONG
 #undef lldiv
 using ::lldiv;
 #endif // _LIBCPP_HAS_NO_LONG_LONG
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 using ::mblen;
 using ::mbtowc;
 using ::wctomb;
+#endif
 using ::mbstowcs;
 using ::wcstombs;
 #ifdef _LIBCPP_HAS_QUICK_EXIT
 using ::at_quick_exit;
 using ::quick_exit;
 #endif
 #ifdef _LIBCPP_HAS_C11_FEATURES
 using ::aligned_alloc;

libcxx/trunk/include/cstring

 #if !defined(__GLIBC__) && !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_STRING_H_CPLUSPLUS_98_CONFORMANCE_)
 inline _LIBCPP_INLINE_VISIBILITY       char* strchr(      char* __s, int __c) {return ::strchr(__s, __c);}
 inline _LIBCPP_INLINE_VISIBILITY       char* strpbrk(      char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
 inline _LIBCPP_INLINE_VISIBILITY       char* strrchr(      char* __s, int __c) {return ::strrchr(__s, __c);}
 inline _LIBCPP_INLINE_VISIBILITY       void* memchr(      void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
 inline _LIBCPP_INLINE_VISIBILITY       char* strstr(      char* __s1, const char* __s2) {return ::strstr(__s1, __s2);}
 #endif
 
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 using ::strtok;
+#endif
 using ::memset;
 using ::strerror;
 using ::strlen;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CSTRING

libcxx/trunk/include/ctime

 using ::clock_t;
 using ::size_t;
 using ::time_t;
 using ::tm;
 using ::clock;
 using ::difftime;
 using ::mktime;
 using ::time;
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 using ::asctime;
 using ::ctime;
 using ::gmtime;
 using ::localtime;
+#endif
 using ::strftime;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CTIME

libcxx/trunk/test/CMakeLists.txt

if (LIT_EXECUTABLE)
   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_THREAD_UNSAFE_C_FUNCTIONS)
   pythonize_bool(LIBCXX_ENABLE_MONOTONIC_CLOCK)
   pythonize_bool(LIBCXX_GENERATE_COVERAGE)
   pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
 
   # 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")

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

def configure_default_compile_flags(self):
                                                    True)
         if not enable_threads:
             self.configure_compile_flags_no_threads()
             if not enable_monotonic_clock:
                 self.configure_compile_flags_no_monotonic_clock()
         elif not enable_monotonic_clock:
             self.lit_config.fatal('enable_monotonic_clock cannot be false when'
                                   ' enable_threads is true.')
+        self.configure_compile_flags_no_thread_unsafe_c_functions()
+
         # Use verbose output for better errors
         self.cxx.flags += ['-v']
         sysroot = self.get_lit_conf('sysroot')
         if sysroot:
             self.cxx.flags += ['--sysroot', sysroot]
         gcc_toolchain = self.get_lit_conf('gcc_toolchain')
         if gcc_toolchain:
             self.cxx.flags += ['-gcc-toolchain', gcc_toolchain]
def configure_compile_flags_no_stdout(self):
         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_thread_unsafe_c_functions(self):
+        enable_thread_unsafe_c_functions = self.get_lit_bool(
+            'enable_thread_unsafe_c_functions', True)
+        if not enable_thread_unsafe_c_functions:
+            self.cxx.compile_flags += [
+                '-D_LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS']
+            self.config.available_features.add(
+                'libcpp-has-no-thread-unsafe-c-functions')
+
     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')
 
     def configure_link_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
             self.cxx.link_flags += ['-nodefaultlibs']
def configure_extra_library_flags(self):
             if enable_threads:
                 self.cxx.link_flags += ['-lpthread']
             self.cxx.link_flags += ['-lrt']
             if llvm_unwinder:
                 self.cxx.link_flags += ['-lunwind', '-ldl']
             else:
                 self.cxx.link_flags += ['-lgcc_s']
         elif target_platform.startswith('freebsd'):
-            self.cxx.link_flags += ['-lc', '-lm', '-lpthread', '-lgcc_s']
+            self.cxx.link_flags += ['-lc', '-lm', '-lpthread', '-lgcc_s', '-lcxxrt']
         else:
             self.lit_config.fatal("unrecognized system: %r" % target_platform)
 
     def configure_color_diagnostics(self):
         use_color = self.get_lit_conf('color_diagnostics')
         if use_color is None:
             use_color = os.environ.get('LIBCXX_COLOR_DIAGNOSTICS')
         if use_color is None:

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_thread_unsafe_c_functions = "@LIBCXX_ENABLE_THREAD_UNSAFE_C_FUNCTIONS@"
 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.generate_coverage        = "@LIBCXX_GENERATE_COVERAGE@"
 config.target_info              = "@LIBCXX_TARGET_INFO@"
 config.executor                 = "@LIBCXX_EXECUTOR@"
 config.llvm_unwinder            = "@LIBCXXABI_USE_LLVM_UNWINDER@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXX_SOURCE_DIR@/test/lit.cfg")

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

int main()
     static_assert((std::is_same<decltype(bsearch(0,0,0,0,0)), void*>::value), "");
     static_assert((std::is_same<decltype(qsort(0,0,0,0)), void>::value), "");
     static_assert((std::is_same<decltype(abs(0)), int>::value), "");
     static_assert((std::is_same<decltype(labs((long)0)), long>::value), "");
     static_assert((std::is_same<decltype(llabs((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(div(0,0)), div_t>::value), "");
     static_assert((std::is_same<decltype(ldiv(0L,0L)), ldiv_t>::value), "");
     static_assert((std::is_same<decltype(lldiv(0LL,0LL)), lldiv_t>::value), "");
-    static_assert((std::is_same<decltype(mblen("",0)), int>::value), "");
     wchar_t* pw = 0;
     const wchar_t* pwc = 0;
     char* pc = 0;
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
+    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), "");
+#endif
     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), "");
 }

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

int main()
     static_assert((std::is_same<decltype(strxfrm(cp, cpc, s)), size_t>::value), "");
     static_assert((std::is_same<decltype(memchr(vp, 0, s)), void*>::value), "");
     static_assert((std::is_same<decltype(strchr(cp, 0)), char*>::value), "");
     static_assert((std::is_same<decltype(strcspn(cpc, cpc)), size_t>::value), "");
     static_assert((std::is_same<decltype(strpbrk(cp, cpc)), char*>::value), "");
     static_assert((std::is_same<decltype(strrchr(cp, 0)), char*>::value), "");
     static_assert((std::is_same<decltype(strspn(cpc, cpc)), size_t>::value), "");
     static_assert((std::is_same<decltype(strstr(cp, cpc)), char*>::value), "");
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(strtok(cp, cpc)), char*>::value), "");
+#endif
     static_assert((std::is_same<decltype(memset(vp, 0, s)), void*>::value), "");
     static_assert((std::is_same<decltype(strerror(0)), char*>::value), "");
     static_assert((std::is_same<decltype(strlen(cpc)), size_t>::value), "");
 }

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

int main()
     static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::labs((long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::llabs((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::div(0,0)), std::div_t>::value), "");
     static_assert((std::is_same<decltype(std::div(0L,0L)), std::ldiv_t>::value), "");
     static_assert((std::is_same<decltype(std::div(0LL,0LL)), std::lldiv_t>::value), "");
     static_assert((std::is_same<decltype(std::ldiv(0L,0L)), std::ldiv_t>::value), "");
     static_assert((std::is_same<decltype(std::lldiv(0LL,0LL)), std::lldiv_t>::value), "");
-    static_assert((std::is_same<decltype(std::mblen("",0)), int>::value), "");
     wchar_t* pw = 0;
     const wchar_t* pwc = 0;
     char* pc = 0;
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
+    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), "");
+#endif
     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), "");
 }

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

int main()
     std::clock_t c = 0;
     std::size_t s = 0;
     std::time_t t = 0;
     std::tm tm = {0};
     static_assert((std::is_same<decltype(std::clock()), std::clock_t>::value), "");
     static_assert((std::is_same<decltype(std::difftime(t,t)), double>::value), "");
     static_assert((std::is_same<decltype(std::mktime(&tm)), std::time_t>::value), "");
     static_assert((std::is_same<decltype(std::time(&t)), std::time_t>::value), "");
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::asctime(&tm)), char*>::value), "");
     static_assert((std::is_same<decltype(std::ctime(&t)), char*>::value), "");
     static_assert((std::is_same<decltype(std::gmtime(&t)), std::tm*>::value), "");
     static_assert((std::is_same<decltype(std::localtime(&t)), std::tm*>::value), "");
+#endif
     char* c1 = 0;
     const char* c2 = 0;
     static_assert((std::is_same<decltype(std::strftime(c1,s,c2,&tm)), std::size_t>::value), "");
 }

libcxx/trunk/test/std/localization/c.locales/clocale.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <clocale>
 
 #include <clocale>
 #include <type_traits>
 
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
+
 #ifndef LC_ALL
 #error LC_ALL not defined
 #endif
 
 #ifndef LC_COLLATE
 #error LC_COLLATE not defined
 #endif
 
 #ifndef LC_CTYPE
 #error LC_CTYPE not defined
 #endif
 
 #ifndef LC_MONETARY
 #error LC_MONETARY not defined
 #endif
 
 #ifndef LC_NUMERIC
 #error LC_NUMERIC not defined
 #endif
 
 #ifndef LC_TIME
 #error LC_TIME not defined
 #endif
 
+#endif // !_LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
+
 #ifndef NULL
 #error NULL not defined
 #endif
 
 int main()
 {
     std::lconv lc;
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::setlocale(0, "")), char*>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::localeconv()), std::lconv*>::value), "");
 }

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

//    static_assert((std::is_same<decltype(std::strchr(cpc, 0)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strcspn(cpc, cpc)), std::size_t>::value), "");
 //    static_assert((std::is_same<decltype(std::strpbrk(cpc, cpc)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strpbrk(cp, cpc)), char*>::value), "");
 //    static_assert((std::is_same<decltype(std::strrchr(cpc, 0)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strrchr(cp, 0)), char*>::value), "");
     static_assert((std::is_same<decltype(std::strspn(cpc, cpc)), std::size_t>::value), "");
 //    static_assert((std::is_same<decltype(std::strstr(cpc, cpc)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strstr(cp, cpc)), char*>::value), "");
+#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::strtok(cp, cpc)), char*>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::memset(vp, 0, s)), void*>::value), "");
     static_assert((std::is_same<decltype(std::strerror(0)), char*>::value), "");
     static_assert((std::is_same<decltype(std::strlen(cpc)), std::size_t>::value), "");
 }

libcxx/trunk/test/std/utilities/date.time/asctime.thread-unsafe.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: libcpp-has-no-thread-unsafe-c-functions
+
+#include <ctime>
+
+int main() {
+    // asctime is not thread-safe.
+    std::time_t t = 0;
+    std::asctime(&t);
+}

libcxx/trunk/test/std/utilities/date.time/ctime.thread-unsafe.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: libcpp-has-no-thread-unsafe-c-functions
+
+#include <ctime>
+
+int main() {
+    // ctime is not thread-safe.
+    std::time_t t = 0;
+    std::ctime(&t);
+}

libcxx/trunk/test/std/utilities/date.time/gmtime.thread-unsafe.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: libcpp-has-no-thread-unsafe-c-functions
+
+#include <ctime>
+
+int main() {
+    // gmtime is not thread-safe.
+    std::time_t t = 0;
+    std::gmtime(&t);
+}

libcxx/trunk/test/std/utilities/date.time/localtime.thread-unsafe.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: libcpp-has-no-thread-unsafe-c-functions
+
+#include <ctime>
+
+int main() {
+    // localtime is not thread-safe.
+    std::time_t t = 0;
+    std::localtime(&t);
+}