[libc++] Fix modules and benchmarks CI builds when incomplete features are disabled

[ldionne]

Try to fix the CI. Hopefully defining NOMINMAX shouldn't be required anymore on Windows -- CI will tell.

[ldionne]

Push/pop min and max in filesystem_helper.h

[ldionne]

Try to fix remaining CI issues.

[rastogishubham]

Hi this commit broke the lldb greendragon bots.

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/41225/

crashlog backtrace:

0 clang 0x0000000110741acb llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) + 43
1 clang 0x00000001107407c8 llvm::sys::RunSignalHandlers() + 248
2 clang 0x0000000110740ef0 llvm::sys::CleanupOnSignal(unsigned long) + 208
3 clang 0x00000001106638ca (anonymous namespace)::CrashRecoveryContextImpl::HandleCrash(int, unsigned long) + 106
4 clang 0x0000000110663abe CrashRecoverySignalHandler(int) + 110
5 libsystem_platform.dylib 0x00007fff6c8655fd _sigtramp + 29
6 libsystem_platform.dylib 0x00007fc2c50d7e00 _sigtramp + 18446743813201799200
7 libsystem_c.dylib 0x00007fff6c737808 abort + 120
8 libsystem_c.dylib 0x00007fff6c736ac6 err + 0
9 clang 0x000000011124c7f0 llvm::BitstreamWriter::~BitstreamWriter() + 608
10 clang 0x00000001113e56e9 clang::PCHGenerator::~PCHGenerator() + 41
11 clang 0x0000000111241360 clang::MultiplexConsumer::~MultiplexConsumer() + 128
12 clang 0x000000011114f1bb clang::CompilerInstance::~CompilerInstance() + 683
13 clang 0x000000011115e1b1 compileModuleImpl(clang::CompilerInstance&, clang::SourceLocation, llvm::StringRef, clang::FrontendInputFile, llvm::StringRef, llvm::StringRef, llvm::function_ref<void (clang::CompilerInstance&)>, llvm::function_ref<void (clang::CompilerInstance&)>) + 4481
14 clang 0x000000011115feff compileModuleAndReadASTImpl(clang::CompilerInstance&, clang::SourceLocation, clang::SourceLocation, clang::Module*, llvm::StringRef) + 1903
15 clang 0x0000000111159a8b compileModuleAndReadAST(clang::CompilerInstance&, clang::SourceLocation, clang::SourceLocation, clang::Module*, llvm::StringRef) + 1947
16 clang 0x0000000111158ebc clang::CompilerInstance::findOrCompileModuleAndReadAST(llvm::StringRef, clang::SourceLocation, clang::SourceLocation, bool) + 3676
17 clang 0x0000000111159e17 clang::CompilerInstance::loadModule(clang::SourceLocation, llvm::ArrayRef<std::1::pair<clang::IdentifierInfo*, clang::SourceLocation> >, clang::Module::NameVisibilityKind, bool) + 679
18 clang 0x0000000113540ce6 clang::Preprocessor::HandleHeaderIncludeOrImport(clang::SourceLocation, clang::Token&, clang::Token&, clang::SourceLocation, clang::DirectoryLookup const*, clang::FileEntry const*) + 7910
19 clang 0x0000000113538e12 clang::Preprocessor::HandleIncludeDirective(clang::SourceLocation, clang::Token&, clang::DirectoryLookup const*, clang::FileEntry const*) + 162
20 clang 0x0000000113539a2d clang::Preprocessor::HandleDirective(clang::Token&) + 2461
21 clang 0x000000011350a037 clang::Lexer::LexTokenInternal(clang::Token&, bool) + 6343
22 clang 0x0000000113507857 clang::Lexer::Lex(clang::Token&) + 119
23 clang 0x000000011357add4 clang::Preprocessor::Lex(clang::Token&) + 84
24 clang 0x00000001123c33e6 clang::Parser::Initialize() + 5030
25 clang 0x00000001122efa26 clang::ParseAST(clang::Sema&, bool, bool) + 438
26 clang 0x00000001111ffbc3 clang::FrontendAction::Execute() + 99
27 clang 0x0000000111155f4f clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) + 863
28 clang 0x000000011128ada5 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) + 709
29 clang 0x000000010ecb86dc cc1_main(llvm::ArrayRef<char const*>, char const*, void*) + 2108
30 clang 0x000000010ecb3aee ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) + 286
31 clang 0x0000000110f7cdd7 void llvm::function_ref<void ()>::callback_fn<clang::driver::CC1Command::Execute(llvm::ArrayRef<llvm::Optional<llvm::StringRef> >, std::1::basic_string<char, std::1::char_traits<char>, std::1::allocator<char> >*, bool*) const::$_4>(long) + 23
32 clang 0x00000001106637dc llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) + 236
33 clang 0x0000000110f7c848 clang::driver::CC1Command::Execute(llvm::ArrayRef<llvm::Optional<llvm::StringRef> >, std::1::basic_string<char, std::1::char_traits<char>, std::1::allocator<char> >*, bool*) const + 296
34 clang 0x0000000110f45233 clang::driver::Compilation::ExecuteCommand(clang::driver::Command const&, clang::driver::Command const*&) const + 739
35 clang 0x0000000110f4565d clang::driver::Compilation::ExecuteJobs(clang::driver::JobList const&, llvm::SmallVectorImpl<std::1::pair<int, clang::driver::Command const*> >&) const + 125
36 clang 0x0000000110f5fe2b clang::driver::Driver::ExecuteCompilation(clang::driver::Compilation&, llvm::SmallVectorImpl<std::__1::pair<int, clang::driver::Command const*> >&) + 395
37 clang 0x000000010ecb307f main + 9663
38 libdyld.dylib 0x00007fff6c668cc9 start + 1
39 libdyld.dylib 0x0000000000000027 start + 18446603338697503583
clang-15: error: clang frontend command failed with exit code 134 (use -v to see invocation)
clang version 15.0.99 (http://labmaster3.local/git/llvm-project.git 3dce6b329ce3efa1d51f1101a08cff31ecdbeb12)
Target: x86_64-apple-darwin19.5.0
Thread model: posix
InstalledDir: /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin
clang-15: error: unable to execute command: Abort trap: 6
clang-15: note: diagnostic msg: Error generating preprocessed source(s).
make: *** [main.o] Error 134

The reason it took us this look to find the issue is because there was a cmake error on the bots that caused the build to fail before, but a local git revert 506cf6dc048835c598b654e43ed8f723a42e39ba and ninja check-lldb-unit && bin/lldb-do-test -p TestStateAfterExpression.py does not crash like the build does.

Please revert this change or fix it as soon as possible! Thanks

[ldionne]

In D119036#3310455, @rastogishubham wrote:

Hi this commit broke the lldb greendragon bots.

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/41225/

crashlog backtrace:

[...]

Target: x86_64-apple-darwin19.5.0
Thread model: posix
InstalledDir: /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin
clang-15: error: unable to execute command: Abort trap: 6
clang-15: note: diagnostic msg: Error generating preprocessed source(s).
make: *** [main.o] Error 134

That's not really helpful -- can you please reduce some more? I'm not even able to run the LLDB tests locally, it complains about missing SWIG even though I did install it. Regardless, it looks like at the end of the day your bot is running something like this:

"/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/clang"  -fmodules -gmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/lldb-test-build.noindex/module-cache-clang/lldb-api -gmodules -fcxx-modules -std=c++11 -g -O0 -fno-builtin -isysroot "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk" -arch x86_64  -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make/../../../../../include -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/thread/state_after_expression -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make -include /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make/test_common.h  -fno-limit-debug-info  -fmodules -gmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/lldb-test-build.noindex/module-cache-clang/lldb-api -gmodules -fcxx-modules -std=c++11   --driver-mode=g++ -MT main.o -MD -MP -MF main.d -c -o main.o /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/thread/state_after_expression/main.cpp

So I think this is just a modules bug in Clang. I'll be happy to investigate if I can reproduce it.

Also, LLDB is still using the deprecated LLVM_ENABLE_PROJECTS build for libc++ and libc++abi -- please move to LLVM_ENABLE_RUNTIMES as documented here: https://libcxx.llvm.org/BuildingLibcxx.html.

[ldionne]

In D119036#3311097, @ldionne wrote:

That's not really helpful -- can you please reduce some more? I'm not even able to run the LLDB tests locally, it complains about missing SWIG even though I did install it. Regardless, it looks like at the end of the day your bot is running something like this:

Other things I'd need to know -- do you folks build your own Clang? It seems like it's a tip-of-trunk Clang, right? I assume you're building it with Assertions enabled? Any other settings you're using? The LLDB build is so complex that there's no way I'll be able to fix this if you don't provide a bit more information.

[ldionne]

I managed to reproduce with a freshly-built Clang + libc++ and this:

echo "#include <cstddef>" | xcrun ./build/default/bin/clang++ -fmodules -xc++ - -fsyntax-only

This is caused by making the __config header a textual header. However, adding -Xclang -fmodules-local-submodule-visibility fixes the issue:

echo "#include <cstddef>" | xcrun ./build/default/bin/clang++ -fmodules -xc++ - -Xclang -fmodules-local-submodule-visibility -fsyntax-only

works just fine. And in fact, that's how we run our own Modules build (which we set up specifically to avoid breaking LLDB).

Could LLDB build with that flag so that our flags match?

[aprantl]

Are you suggesting we drop support for building libcxx without local submodule visibility? I'm not sure that's an acceptable regression.

[aprantl]

To answer your other question: The lldb-cmake bot build LLDB and clang with modules enabled, but that doesn't actually matter. What's breaking is running the LLDB testsuite when it's using the just-built clang to compile C++ tests with -fcxx-modules (without local submodule visibility).

[aprantl]

Could LLDB [tests] build with that flag so that our flags match?

If the plan is to not support building libcxx without local submodule visibility, should -fcxx-modules imply -fmodules-local-submodule-visibility ?

[ldionne]

In D119036#3311492, @aprantl wrote:

Are you suggesting we drop support for building libcxx without local submodule visibility? I'm not sure that's an acceptable regression.

Let's put it that way: libc++ already doesn't support it, because it doesn't work and we don't test it. From our side, the situation is that we've done a huge amount of work to support modules because we knew a few projects were using it (LLDB being the biggest one I'm aware of), despite that being rather painful and very light on return on investment. Modules in Clang have some bugs that have been biting us, making things difficult. The only thing that's on our radar is whatever we test, and at the moment it's modules with local submodule visibility.

If there is a reason for us to support modules without local submodule visibility, then yes, we can look into supporting it, however I think the correct order is:

1. Make sure LLDB uses an officially supported and tested way to build and use libc++ (which you partially address in 547a667ceeb6, thanks for that)
2. Tell us about the fact that you'd like modules to be supported without local submodule visibility (that's clear now)
3. Then we make any changes necessary to support it
4. LLDB switches to modules without local submodule visibility

I think the friction here comes from the fact that LLDB (1) consciously decides to live on the edge by using a ToT libc++, and (2) doesn't give us a way to put LLDB on our radar by providing a pre-commit CI bot that would run the data formatters. This leads to this situation where we broke you, but we were not even aware that you *could* be broken. I thought the story of breaking LLDB data formatters (which used to happen frequently) was completely done because we added the right modules CI bot, but it seems like there was still a difference in the flag.

Anyway I'm immediately going to look into what's necessary to support modules without local submodule visibility, but I guess this question is still open:

If the plan is to not support building libcxx without local submodule visibility, should -fcxx-modules imply -fmodules-local-submodule-visibility ?

I don't know the answer to that. In fact, my initial impression would be that we want to support the "basic" form of modules, i.e. just -fmodules. Is there a reason to support more than that?

[aprantl]

I think the friction here comes from the fact that LLDB (1) consciously decides to live on the edge by using a ToT libc++, and (2) doesn't give us a way to put LLDB on our radar by providing a pre-commit CI bot that would run the data formatters.

I'm not sure I agree with that characterization: LLDB doesn't live on the edge, it's a sibling project of libcxx inside the llvm-project monorepo and the bots test ToT of llvm-project.

It's by the way not an LLDB dataformatter that broke, but a clang invocation compiling a .cpp file (part of the LLDB test suite) using -fmodules -fcxxmodules ran into an assertion. LLDB is just the messenger :-)

[aprantl]

LLDB is just the messenger

I take that back. I just realized that this also break LLDB's own importing of the C++ standard library.

_build.ninja.debug/bin/lldb-dotest -p TestImportStdModule.py
...
Assertion failed: ((ID || !Mod) && "asked for module ID for non-local, non-imported module"), function getSubmoduleID, file ASTWriter.cpp, line 2650.

I need to check whether LLDB uses a separate compiler instance for that or if the same compiler invocation is also used to import Objective-C modules.

[mstorsjo]

In D119036#3302341, @ldionne wrote:

Push/pop min and max in filesystem_helper.h

The change to push/pop those in filesystem_helper.h broke testing any other library than libc++, as the standard headers now require libc++ internal headers (<__undef_macros>) and macros (_LIBCPP_PUSH_MACROS, _LIBCPP_POP_MACROS).

How would you prefer to fix that - reinstate the -DNOMINMAX in the testing config, or just use a plain #undef max in the test support header? Or spell out the corresponding push/pop directives with compiler conditionals?

[v.g.vassilev]

libcxx/include/module.modulemap

10

I believe the issue that is being fixed in https://reviews.llvm.org/D119468 can be fixed by removing export std_config as clang seems to only be able to re-export submodules. Moreover, std_config is purely textual and there is nothing to export anyways.

We see such issue on our infrastructure and the suggested fix seem to work.

@ldionne, @aprantl, would it make sense to try it instead, as we should probably really treat __config and __config_site as textual?

[ldionne]

libcxx/include/module.modulemap

10

If it fixes an issue you are seeing, a patch is welcome. It would be nice if there was a way to reproduce the issue you are seeing, though.

[v.g.vassilev]

libcxx/include/module.modulemap

10

https://reviews.llvm.org/D119468 fixes it but my claim is that's the wrong fix as __config and __config_site are macro-only headers. Do we expect defining a macro in the includer to change the contents of these headers?

If we do they should be treated just like the assert header file, i.e. always marked as textual header file. We could protect the headers which must be textual similar to what we already do in llvm: https://github.com/llvm/llvm-project/blob/d94a315ee3ecf0fb03cf1c7422e120d9d0e95d00/llvm/cmake/modules/HandleLLVMOptions.cmake#L605-L610

We track the issue here https://github.com/root-project/root/issues/10861 The issue seems quite similar to https://www.mail-archive.com/[e-mail]/msg51401.html

I added a patch here: https://reviews.llvm.org/D142805

libcxx/benchmarks/CMakeLists.txt

function(add_benchmark_test name source_file)
   endif()
 endfunction()
 
 
 #==============================================================================
 # Register Benchmark tests
 #==============================================================================
 file(GLOB BENCHMARK_TESTS "*.bench.cpp")
+
+if (NOT LIBCXX_ENABLE_INCOMPLETE_FEATURES)
+  list(FILTER BENCHMARK_TESTS EXCLUDE REGEX "(format_to_n|format_to|format|formatted_size|formatter_float|std_format_spec_string_unicode).bench.cpp")
+endif()
+
 foreach(test_path ${BENCHMARK_TESTS})
   get_filename_component(test_file "${test_path}" NAME)
   string(REPLACE ".bench.cpp" "" test_name "${test_file}")
   if (NOT DEFINED ${test_name}_REPORTED)
     message(STATUS "Adding Benchmark: ${test_file}")
     # Only report the adding of the benchmark once.
     set(${test_name}_REPORTED ON CACHE INTERNAL "")
   endif()

libcxx/include/__debug

 #   include <cstdlib>
 #endif
 
 #if _LIBCPP_DEBUG_LEVEL == 0
 #   define _LIBCPP_DEBUG_ASSERT(x, m) ((void)0)
 #   define _LIBCPP_ASSERT_IMPL(x, m) ((void)0)
 #elif _LIBCPP_DEBUG_LEVEL == 1
 #   define _LIBCPP_DEBUG_ASSERT(x, m) ((void)0)
-#   define _LIBCPP_ASSERT_IMPL(x, m) ((x) ? (void)0 : _VSTD::__libcpp_debug_function(_VSTD::__libcpp_debug_info(__FILE__, __LINE__, #x, m)))
+#   define _LIBCPP_ASSERT_IMPL(x, m) ((x) ? (void)0 : ::std::__libcpp_debug_function(::std::__libcpp_debug_info(__FILE__, __LINE__, #x, m)))
 #elif _LIBCPP_DEBUG_LEVEL == 2
-#   define _LIBCPP_DEBUG_ASSERT(x, m) _LIBCPP_ASSERT(__libcpp_is_constant_evaluated() || (x), m)
-#   define _LIBCPP_ASSERT_IMPL(x, m) ((x) ? (void)0 : _VSTD::__libcpp_debug_function(_VSTD::__libcpp_debug_info(__FILE__, __LINE__, #x, m)))
+#   define _LIBCPP_DEBUG_ASSERT(x, m) _LIBCPP_ASSERT(::std::__libcpp_is_constant_evaluated() || (x), m)
+#   define _LIBCPP_ASSERT_IMPL(x, m) ((x) ? (void)0 : ::std::__libcpp_debug_function(::std::__libcpp_debug_info(__FILE__, __LINE__, #x, m)))
 #else
 #   error _LIBCPP_DEBUG_LEVEL must be one of 0, 1, 2
 #endif
 
 #if !defined(_LIBCPP_ASSERT)
 #   define _LIBCPP_ASSERT(x, m) _LIBCPP_ASSERT_IMPL(x, m)
 #endif
 

libcxx/include/module.modulemap

 // define the module for __config outside of the top level 'std' module
 // since __config may be included from C headers which may create an
 // include cycle.
 module std_config [system] [extern_c] {
-    header "__config"
+  textual header "__config"
+  textual header "__config_site"
 }
 
 module std [system] {
   export std_config
   // FIXME: The standard does not require that each of these submodules
   // re-exports its imported modules. We should provide an alternative form of
   // export that issues a warning if a name from the submodule is used, and
   // use that to provide a 'strict mode' for libc++.
 
   // Deprecated C-compatibility headers. These can all be included from within
   // an 'extern "C"' context.
   module depr [extern_c] {

libcxx/test/configs/llvm-libc++-shared-clangcl.cfg.in

 # This testing configuration handles running the test suite against LLVM's libc++
 # using a DLL, with Clang-cl on Windows.
 
 lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg')
 
 config.substitutions.append(('%{flags}', '--driver-mode=g++'))
 config.substitutions.append(('%{compile_flags}',
-    '-nostdinc++ -isystem %{include} -isystem %{target-include} -I %{libcxx}/test/support -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_STDIO_ISO_WIDE_SPECIFIERS -DNOMINMAX'
+    '-nostdinc++ -isystem %{include} -isystem %{target-include} -I %{libcxx}/test/support -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_STDIO_ISO_WIDE_SPECIFIERS'
 ))
 config.substitutions.append(('%{link_flags}',
     '-nostdlib -L %{lib} -lc++ -lmsvcrt -lmsvcprt -loldnames'
 ))
 config.substitutions.append(('%{exec}',
     '%{executor} --execdir %T --env PATH=%{lib} -- '
 ))
 

libcxx/test/configs/llvm-libc++-static-clangcl.cfg.in

 # This testing configuration handles running the test suite against LLVM's libc++
 # using a static library, with Clang-cl on Windows.
 
 lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg')
 
 config.substitutions.append(('%{flags}', '--driver-mode=g++'))
 config.substitutions.append(('%{compile_flags}',
-    '-nostdinc++ -isystem %{include} -isystem %{target-include} -I %{libcxx}/test/support -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_STDIO_ISO_WIDE_SPECIFIERS -DNOMINMAX'
+    '-nostdinc++ -isystem %{include} -isystem %{target-include} -I %{libcxx}/test/support -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_STDIO_ISO_WIDE_SPECIFIERS'
 ))
 config.substitutions.append(('%{link_flags}',
     '-nostdlib -L %{lib} -llibc++ -lmsvcrt -lmsvcprt -loldnames'
 ))
 config.substitutions.append(('%{exec}',
     '%{executor} --execdir %T --env PATH=%{lib} -- '
 ))
 

libcxx/test/libcxx/algorithms/debug_less.pass.cpp

 // <algorithm>
 
 // template <class _Compare> struct __debug_less
 
 // __debug_less checks that a comparator actually provides a strict-weak ordering.
 
 struct DebugException {};
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined
 #define _LIBCPP_DEBUG 0
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw ::DebugException())
 
 #include <algorithm>
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/libcxx/debug/debug_abort.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // Test that the default debug handler aborts the program.
 
 #include <csignal>
 #include <cstdlib>
 #include <__debug>
 

libcxx/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp

 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
 
 int AssertCount = 0;
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
 #define _LIBCPP_DEBUG 0
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 

libcxx/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp

 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
 
 int AssertCount = 0;
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
 #define _LIBCPP_DEBUG 0
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 

libcxx/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: windows
 // UNSUPPORTED: libcxx-no-debug-mode
 
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
 
 // <filesystem>
 
 // class path
 
 #include "filesystem_include.h"
 #include <iterator>
 #include <type_traits>

libcxx/test/libcxx/iterators/advance.debug1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: windows
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // <list>
 
 // Call advance(non-bidi iterator, -1)
 
 #include <iterator>
 #include "test_macros.h"

libcxx/test/libcxx/iterators/next.debug1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: windows
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // <list>
 
 // Call next(non-bidi iterator, -1)
 
 #include <iterator>
 #include "test_macros.h"
 #include "debug_mode_helper.h"
 
 #include "test_iterators.h"
 
 int main(int, char**)
 {
     int a[] = {1, 2, 3};
 
 
     forward_iterator<int *> it(a+1);
-  std::next(it, 1);  // should work fine
-  std::next(it, 0);  // should work fine
+    std::next(it, 1);  // should work fine
+    std::next(it, 0);  // should work fine
     EXPECT_DEATH( std::next(it, -1) ); // can't go backwards on a FwdIter
 
   return 0;
 }

libcxx/test/libcxx/iterators/prev.debug1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: windows
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // <list>
 
 // Call prev(forward_iterator, -1)
 
 #include <iterator>
 #include "test_macros.h"
 #include "debug_mode_helper.h"
 
 #include "test_iterators.h"
 
 int main(int, char**)
 {
     int a[] = {1, 2, 3};
 
     bidirectional_iterator<int *> bidi(a+1);
-  std::prev(bidi, -1);  // should work fine
-  std::prev(bidi,  0);  // should work fine
+    std::prev(bidi, -1);  // should work fine
+    std::prev(bidi,  0);  // should work fine
     std::prev(bidi,  1);  // should work fine
 
     forward_iterator<int *> it(a+1);
     std::prev(it, -1); // should work fine
     std::prev(it,  0); // should work fine
     EXPECT_DEATH( std::prev(it, 1) ); // can't go backwards on a FwdIter
 
   return 0;
 }

libcxx/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: windows
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++03
 // UNSUPPORTED: libcxx-no-debug-mode
 
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
 
 // <future>
 
 // class promise<R>
 
 // void set_exception(exception_ptr p);
 // Test that a null exception_ptr is diagnosed.
 

libcxx/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: windows
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++03
 // UNSUPPORTED: libcxx-no-debug-mode
 
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
+// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
 
 // <future>
 
 // class promise<R>
 
 // void set_exception_on_thread_exit(exception_ptr p);
 // Test that a null exception_ptr is diagnosed.
 

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp

 
 // <filesystem>
 
 // class directory_entry
 
 // file_time_type last_write_time() const;
 // file_time_type last_write_time(error_code const&) const noexcept;
 
+// Disable min() and max() macros in <windows.h> on Windows.
+// ADDITIONAL_COMPILE_FLAGS: -DNOMINMAX
+
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "filesystem_test_helper.h"
 #include "rapid-cxx-test.h"
 
 #include "test_macros.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

 // <filesystem>
 
 // file_time_type last_write_time(const path& p);
 // file_time_type last_write_time(const path& p, std::error_code& ec) noexcept;
 // void last_write_time(const path& p, file_time_type new_time);
 // void last_write_time(const path& p, file_time_type new_type,
 //                      std::error_code& ec) noexcept;
 
+// Disable min() and max() macros in <windows.h> on Windows.
+// ADDITIONAL_COMPILE_FLAGS: -DNOMINMAX
+
 #include "filesystem_include.h"
 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <ratio>
 #include <type_traits>
 

libcxx/test/support/filesystem_test_helper.h

 #include "format_string.h"
 
 // For creating socket files
 #if !defined(__FreeBSD__) && !defined(__APPLE__) && !defined(_WIN32)
 # include <sys/socket.h>
 # include <sys/un.h>
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 namespace utils {
 #ifdef _WIN32
     inline int mkdir(const char* path, int mode) { (void)mode; return ::_mkdir(path); }
     inline int ftruncate(int fd, off_t length) { return ::_chsize(fd, length); }
     inline int symlink(const char* oldname, const char* newname, bool is_dir) {
         DWORD flags = is_dir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
         if (CreateSymbolicLinkA(newname, oldname,
                                 flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE))
for (const auto &ent : fs::directory_iterator(root, ec)) {
     }
     return ent;
   }
   fprintf(stderr, "No inaccessible directory \"%s\" found, skipping tests "
                   "regarding it\n", dir.string().c_str());
   return fs::path();
 }
 
-#endif /* FILESYSTEM_TEST_HELPER_HPP */
+_LIBCPP_POP_MACROS
+
+#endif /* FILESYSTEM_TEST_HELPER_H */

libcxx/utils/libcxx/test/config.py

def configure_compile_flags(self):
         if self.target_info.is_windows():
             self.cxx.compile_flags += ['-D_CRT_SECURE_NO_WARNINGS']
             # Don't warn about using common but nonstandard unprefixed functions
             # like chdir, fileno.
             self.cxx.compile_flags += ['-D_CRT_NONSTDC_NO_WARNINGS']
             # Build the tests in the same configuration as libcxx itself,
             # to avoid mismatches if linked statically.
             self.cxx.compile_flags += ['-D_CRT_STDIO_ISO_WIDE_SPECIFIERS']
-            # Required so that tests using min/max don't fail on Windows,
-            # and so that those tests don't have to be changed to tolerate
-            # this insanity.
-            self.cxx.compile_flags += ['-DNOMINMAX']
         additional_flags = self.get_lit_conf('test_compiler_flags')
         if additional_flags:
             self.cxx.compile_flags += shlex.split(additional_flags)
 
     def configure_default_compile_flags(self):
         # Configure include paths
         self.configure_compile_flags_header_includes()
         self.target_info.add_cxx_compile_flags(self.cxx.compile_flags)

libcxx/utils/libcxx/test/features.py

macros = {
   '_LIBCPP_HAS_NO_RANDOM_DEVICE': 'libcpp-has-no-random-device',
   '_LIBCPP_HAS_NO_LOCALIZATION': 'libcpp-has-no-localization',
   '_LIBCPP_HAS_NO_WIDE_CHARACTERS': 'libcpp-has-no-wide-characters',
   '_LIBCPP_HAS_NO_INCOMPLETE_FORMAT': 'libcpp-has-no-incomplete-format',
   '_LIBCPP_HAS_NO_INCOMPLETE_RANGES': 'libcpp-has-no-incomplete-ranges',
   '_LIBCPP_HAS_NO_UNICODE': 'libcpp-has-no-unicode',
 }
 for macro, feature in macros.items():
-  DEFAULT_FEATURES += [
-    Feature(name=lambda cfg, m=macro, f=feature: f + (
-              '={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''
-            ),
-            when=lambda cfg, m=macro: m in compilerMacros(cfg),
-
-            # FIXME: This is a hack that should be fixed using module maps.
-            # If modules are enabled then we have to lift all of the definitions
-            # in <__config_site> onto the command line.
-            actions=lambda cfg, m=macro: [
-              AddCompileFlag('-Wno-macro-redefined -D{}'.format(m) + (
-                '={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''
-              ))
-            ]
-    )
-  ]
+  DEFAULT_FEATURES.append(
+    Feature(name=lambda cfg, m=macro, f=feature: f + ('={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''),
+            when=lambda cfg, m=macro: m in compilerMacros(cfg))
 
 
 # Mapping from canonical locale names (used in the tests) to possible locale
 # names on various systems. Each locale is considered supported if any of the
 # alternative names is supported.
 locales = {
   'en_US.UTF-8':     ['en_US.UTF-8', 'en_US.utf8', 'English_United States.1252'],
   'fr_FR.UTF-8':     ['fr_FR.UTF-8', 'fr_FR.utf8', 'French_France.1252'],