[libcxx] Implement locale.h to fix modules build

[EricWF]

Summary

Because locale.h isn't part of the libc++ modules the class definitions it provides are exported as part of __locale (since it happens to be build first). This breaks <clocale> which exports std::lconv without including <__locale>.

This patch implements locale.h to fix this issue, it also adds support for testing libc++ with modules.

[rsmith]

This should only be needed if you are not using -fmodules-local-submodule-visibility and do not have a module map for your C standard library. Is that really a configuration we want to support? Building without -fmodules-local-submodule-visibility typically only works if you modularize bottom-up, due to issues exactly like this one.

include/locale.h

2

This is not math.h.

[EricWF]

include/locale.h

2

It was fixed before committing but I didn't update phab.

include/locale.h

+// -*- C++ -*-
+//===---------------------------- math.h ----------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_LOCALE_H
+#define _LIBCPP_LOCALE_H
+
+/*
+    locale.h synopsis
+
+Macros:
+
+    LC_ALL
+    LC_COLLATE
+    LC_CTYPE
+    LC_MONETARY
+    LC_NUMERIC
+    LC_TIME
+
+Types:
+
+    lconv
+
+Functions:
+
+   setlocale
+   localeconv
+
+*/
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#include_next <locale.h>
+
+#endif  // _LIBCPP_LOCALE_H

include/module.modulemap

/*
         SCNu8, SCNu16, SCNu32, SCNu64, SCNuFAST8, SCNuFAST16, SCNuFAST32, SCNuFAST64, SCNuLEAST8, SCNuLEAST16, SCNuLEAST32, SCNuLEAST64, SCNuMAX, SCNuPTR,
         SCNx8, SCNx16, SCNx32, SCNx64, SCNxFAST8, SCNxFAST16, SCNxFAST32, SCNxFAST64, SCNxLEAST8, SCNxLEAST16, SCNxLEAST32, SCNxLEAST64, SCNxMAX, SCNxPTR,
         SCNX8, SCNX16, SCNX32, SCNX64, SCNXFAST8, SCNXFAST16, SCNXFAST32, SCNXFAST64, SCNXLEAST8, SCNXLEAST16, SCNXLEAST32, SCNXLEAST64, SCNXMAX, SCNXPTR
 */
       export *
     }
     // <iso646.h> provided by compiler.
     // <limits.h> provided by compiler or C library.
-    // <locale.h> provided by C library.
+    module locale_h {
+      header "locale.h"
+/*
+      export_macros LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME
+*/
+      export *
+    }
     module math_h {
       header "math.h"
 /*
       export_macros FP_FAST_FMA, FP_FAST_FMAF, FP_FAST_FMAL, FP_ILOGBO, FP_ILOGBNAN,
                     FP_INFINITE, FP_NAN, FP_NORMAL, FP_SUBNORMAL, FP_ZERO,
                     HUGE_VAL, HUGE_VALF, HUGE_VALL, INFINITY, NAN,
                     MATH_ERRNO, MATH_ERREXCEPT, math_errhandling
 */

test/libcxx/depr/depr.c.headers/locale_h.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <locale.h>
+
+#include <locale.h>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}

test/libcxx/modules/clocale_exports.sh.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: modules-support
+
+// RUN: %build_module
+
+#include <clocale>
+
+#define TEST(...) do { using T = decltype( __VA_ARGS__ ); } while(false)
+
+int main() {
+  std::lconv l; ((void)l);
+
+  TEST(std::setlocale(0, ""));
+  TEST(std::localeconv());
+}

test/libcxx/test/config.py

 #===----------------------------------------------------------------------===##
 #
 #                     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.
 #
 #===----------------------------------------------------------------------===##
 
 import locale
 import os
 import platform
 import pkgutil
 import re
 import shlex
+import shutil
 import sys
 
 import lit.Test  # pylint: disable=import-error,no-name-in-module
 import lit.util  # pylint: disable=import-error,no-name-in-module
 
 from libcxx.test.format import LibcxxTestFormat
 from libcxx.compiler import CXXCompiler
 from libcxx.test.target_info import make_target_info
def __init__(self, lit_config, config):
         self.cxx = None
         self.cxx_stdlib_under_test = None
         self.project_obj_root = None
         self.libcxx_src_root = None
         self.libcxx_obj_root = None
         self.cxx_library_root = None
         self.cxx_runtime_root = None
         self.abi_library_root = None
+        self.module_cache_path = None
         self.env = {}
         self.use_target = False
         self.use_system_cxx_lib = False
         self.use_clang_verify = False
         self.long_tests = None
         self.execute_external = False
 
     def get_lit_conf(self, name, default=None):
def configure(self):
         self.configure_filesystem_compile_flags()
         self.configure_link_flags()
         self.configure_env()
         self.configure_color_diagnostics()
         self.configure_debug_mode()
         self.configure_warnings()
         self.configure_sanitizer()
         self.configure_coverage()
+        self.configure_modules()
         self.configure_substitutions()
         self.configure_features()
 
     def print_config_info(self):
         # Print the final compile and link flags.
         self.lit_config.note('Using compiler: %s' % self.cxx.path)
         self.lit_config.note('Using flags: %s' % self.cxx.flags)
         self.lit_config.note('Using compile flags: %s'
def configure_sanitizer(self):
                     san_lib, '-Wl,-rpath,%s' % os.path.dirname(san_lib)]
 
     def configure_coverage(self):
         self.generate_coverage = self.get_lit_bool('generate_coverage', False)
         if self.generate_coverage:
             self.cxx.flags += ['-g', '--coverage']
             self.cxx.compile_flags += ['-O0']
 
+    def configure_modules(self):
+        supports_modules = self.cxx.hasCompileFlag('-fmodules')
+        enable_modules = self.get_lit_bool('enable_modules', False)
+        if enable_modules and not supports_modules:
+            self.lit_config.fatal(
+                '-fmodules is enabled but not supported by the compiler')
+        if not supports_modules:
+            return
+        self.config.available_features.add('modules-support')
+        module_cache = os.path.join(self.config.test_exec_root,
+                                   'modules.cache')
+        module_cache = os.path.realpath(module_cache)
+        if os.path.isdir(module_cache):
+            shutil.rmtree(module_cache)
+        os.makedirs(module_cache)
+        self.module_cache_path = module_cache
+        if enable_modules:
+            self.config.available_features.add('-fmodules')
+            self.cxx.compile_flags += ['-fmodules',
+                                       '-fmodules-cache-path=' + module_cache]
+
     def configure_substitutions(self):
         sub = self.config.substitutions
         # Configure compiler substitutions
         sub.append(('%cxx', self.cxx.path))
         # Configure flags substitutions
         flags_str = ' '.join(self.cxx.flags)
         compile_flags_str = ' '.join(self.cxx.compile_flags)
         link_flags_str = ' '.join(self.cxx.link_flags)
         all_flags = '%s %s %s' % (flags_str, compile_flags_str, link_flags_str)
         sub.append(('%flags', flags_str))
         sub.append(('%compile_flags', compile_flags_str))
         sub.append(('%link_flags', link_flags_str))
         sub.append(('%all_flags', all_flags))
+
+        module_flags = None
+        if not self.module_cache_path is None:
+            module_flags = '-fmodules -fmodules-cache-path=' \
+                           + self.module_cache_path + ' '
+
+
         # Add compile and link shortcuts
         compile_str = (self.cxx.path + ' -o %t.o %s -c ' + flags_str
                        + compile_flags_str)
         link_str = (self.cxx.path + ' -o %t.exe %t.o ' + flags_str
                     + link_flags_str)
         assert type(link_str) is str
         build_str = self.cxx.path + ' -o %t.exe %s ' + all_flags
         sub.append(('%compile', compile_str))
         sub.append(('%link', link_str))
+        if not module_flags is None:
+            sub.append(('%build_module', build_str + ' ' + module_flags))
         sub.append(('%build', build_str))
         # Configure exec prefix substitutions.
         exec_env_str = 'env ' if len(self.env) != 0 else ''
         for k, v in self.env.items():
             exec_env_str += ' %s=%s' % (k, v)
         # Configure run env substitution.
         exec_str = exec_env_str
         if self.lit_config.useValgrind: