[test] Fix various module cache bugs and inconsistencies

[JDevlieghere]

Summary

Currently, lit tests don't set neither the module cache for building inferiors nor the module cache used by lldb when running tests. Furthermore, we have several places where we rely on the path to the module cache being always the same, rather than passing the correct value around. This makes it hard to specify a different module cache path when debugging a a test.

This patch reworks how we determine and pass around the module cache paths and fixes the omission on the lit side. It also adds a sanity check to the lit and dotest suites.

[aprantl]

lldb/lit/CMakeLists.txt

18

"The Clang module cache used by the Clang embedded in LLDB while running tests."

19

"The Clang module cache used by the Clang while building tests."

lldb/lit/Settings/TestModuleCacheSanity.test

3

points inside the

5

CHECK: lldb-test-build.noindex{{.*}}module-cache-lldb

lldb/packages/Python/lldbsuite/test/sanity/TestModuleCacheSanity.py

4

see my comment in the other test

18

delete this comment

26

see my comment in the other test

[aprantl]

Thanks, this looks great (few comments inside).

[JDevlieghere]

• Fix a few inconsistencies.
• Address Adrian's comments.

[labath]

lldb/trunk/lit/Settings/TestModuleCacheSanity.test

1–4 ↗

(On Diff #217951)

It seems weird to expose these as user-settable cmake variables, but then have a test which will fail if the user changes them in any way. Were you intending to have this feature be configurable at the cmake level? If not, could you change the cmake cache variables into something else (looks like regular variables should work just fine). If yes, then we should have a different testing strategy..

lldb/CMakeLists.txt

 add_subdirectory(utils/TableGen)
 
 add_subdirectory(source)
 add_subdirectory(tools)
 add_subdirectory(docs)
 
 option(LLDB_INCLUDE_TESTS "Generate build targets for the LLDB unit tests." ${LLVM_INCLUDE_TESTS})
 if(LLDB_INCLUDE_TESTS)
+  set(LLDB_TEST_BUILD_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/lldb-test-build.noindex" CACHE PATH "The build root for building tests.")
 
   # Set the path to the default lldb test executable.
   set(LLDB_DEFAULT_TEST_EXECUTABLE "${LLVM_RUNTIME_OUTPUT_INTDIR}/lldb${CMAKE_EXECUTABLE_SUFFIX}")
 
   # Set the paths to default llvm tools.
   set(LLDB_DEFAULT_TEST_DSYMUTIL "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/dsymutil${CMAKE_EXECUTABLE_SUFFIX}")
   set(LLDB_DEFAULT_TEST_FILECHECK "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/FileCheck${CMAKE_EXECUTABLE_SUFFIX}")
 

lldb/lit/CMakeLists.txt

 
 if (CMAKE_SIZEOF_VOID_P EQUAL 8)
   set(LLDB_IS_64_BITS 1)
 endif()
 
 get_property(LLDB_DOTEST_ARGS GLOBAL PROPERTY LLDB_DOTEST_ARGS_PROPERTY)
 set(dotest_args_replacement ${LLVM_BUILD_MODE})
 
+set(LLDB_TEST_MODULE_CACHE_LLDB "${LLDB_TEST_BUILD_DIRECTORY}/module-cache-lldb" CACHE PATH "The Clang module cache used by the Clang embedded in LLDB while running tests.")
+set(LLDB_TEST_MODULE_CACHE_CLANG "${LLDB_TEST_BUILD_DIRECTORY}/module-cache-clang" CACHE PATH "The Clang module cache used by the Clang while building tests.")
+
 if(LLDB_BUILT_STANDALONE)
   # In paths to our build-tree, replace CMAKE_CFG_INTDIR with our configuration name placeholder.
   string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} config_runtime_output_dir ${LLVM_RUNTIME_OUTPUT_INTDIR})
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_DOTEST_ARGS "${LLDB_DOTEST_ARGS}")
 
   # Remaining ones must be paths to the provided LLVM build-tree.
   if(LLVM_CONFIGURATION_TYPES)
     # LLDB uses single-config; LLVM multi-config; pick one and prefer Release types.

lldb/lit/Settings/TestModuleCacheSanity.test

+# This is a sanity check that verifies that the module cache path is set
+# correctly and points inside the default test build directory.
+RUN: %lldb -o 'settings show symbols.clang-modules-cache-path' | FileCheck  %s
+CHECK: lldb-test-build.noindex{{.*}}module-cache-lldb

lldb/lit/Suite/lit.cfg

 # list.
 if config.dotest_lit_args_str:
   dotest_cmd.extend(shlex.split(config.dotest_lit_args_str))
 
 # Library path may be needed to locate just-built clang.
 if config.llvm_libs_dir:
   dotest_cmd += ['--env', 'LLVM_LIBS_DIR=' + config.llvm_libs_dir]
 
+if config.lldb_build_directory:
+  dotest_cmd += ['--build-dir', config.lldb_build_directory]
+
+if config.lldb_module_cache:
+  dotest_cmd += ['--module-cache-dir', config.lldb_module_cache]
+
 # Load LLDB test format.
 sys.path.append(os.path.join(config.lldb_src_root, "lit", "Suite"))
 import lldbtest
 
 # testFormat: The test format to use to interpret tests.
 config.test_format = lldbtest.LLDBTest(dotest_cmd)

lldb/lit/Suite/lit.site.cfg.in

 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.lldb_obj_root = "@LLDB_BINARY_DIR@"
 config.lldb_src_root = "@LLDB_SOURCE_DIR@"
 config.cmake_cxx_compiler = "@CMAKE_CXX_COMPILER@"
 config.host_os = "@HOST_OS@"
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 config.target_triple = "@TARGET_TRIPLE@"
+config.lldb_build_directory = "@LLDB_TEST_BUILD_DIRECTORY@"
+config.lldb_module_cache = "@LLDB_TEST_MODULE_CACHE_LLDB@"
+config.clang_module_cache = "@LLDB_TEST_MODULE_CACHE_CLANG@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.dotest_path = "@LLDB_SOURCE_DIR@/test/dotest.py"
 config.dotest_args_str = "@LLDB_DOTEST_ARGS@"
 config.lldb_disable_python = @LLDB_DISABLE_PYTHON@
 config.dotest_lit_args_str = None
 
 # Additional dotest arguments can be passed to lit by providing a
 # semicolon-separates list: --param dotest-args="arg;arg".

lldb/lit/helper/toolchain.py

def use_support_substitutions(config):
     elif platform.system() in ['NetBSD', 'OpenBSD', 'Linux']:
         flags = ['-pthread']
 
     if sys.platform.startswith('netbsd'):
         # needed e.g. to use freshly built libc++
         flags += ['-L' + config.llvm_libs_dir,
                   '-Wl,-rpath,' + config.llvm_libs_dir]
 
+    # The clang module cache is used for building inferiors.
+    flags += ['-fmodules-cache-path={}'.format(config.clang_module_cache)]
+
     additional_tool_dirs=[]
     if config.lldb_lit_tools_dir:
         additional_tool_dirs.append(config.lldb_lit_tools_dir)
 
     llvm_config.use_clang(additional_flags=flags,
                           additional_tool_dirs=additional_tool_dirs,
                           required=True)
 

lldb/lit/lit-lldb-init.in

 # LLDB init file for the LIT tests.
 settings set symbols.enable-external-lookup false
 settings set plugin.process.gdb-remote.packet-timeout 60
 settings set interpreter.echo-comment-commands false
+settings set symbols.clang-modules-cache-path "@LLDB_TEST_MODULE_CACHE_LLDB@"

lldb/lit/lit.cfg.py

 # assertions enabled, whether we are in debug mode, and what targets we
 # are built for.
 llvm_config.feature_config(
     [('--assertion-mode', {'ON': 'asserts'}),
      ('--build-mode', {'DEBUG': 'debug'}),
      ('--targets-built', calculate_arch_features)
      ])
 
-# Clean the module caches in the test build directory.  This is
-# necessary in an incremental build whenever clang changes underneath,
-# so doing it once per lit.py invocation is close enough.
-
-for i in ['module-cache-clang', 'module-cache-lldb']:
-    cachedir = os.path.join(config.lldb_libs_dir, '..',
-                            'lldb-test-build.noindex', i)
+# Clean the module caches in the test build directory. This is necessary in an
+# incremental build whenever clang changes underneath, so doing it once per
+# lit.py invocation is close enough.
+for cachedir in [config.clang_module_cache, config.lldb_module_cache]:
     if os.path.isdir(cachedir):
         print("Deleting module cache at %s."%cachedir)
         shutil.rmtree(cachedir)
 
 # Set a default per-test timeout of 10 minutes. Setting a timeout per test
 # requires that killProcessAndChildren() is supported on the platform and
 # lit complains if the value is set but it is not supported.
 supported, errormsg = lit_config.maxIndividualTestTimeIsSupported

lldb/lit/lit.site.cfg.py.in

 # should not need to be escaped.
 config.lldb_lit_tools_dir = r"@LLDB_LIT_TOOLS_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.lldb_bitness = 64 if @LLDB_IS_64_BITS@ else 32
 config.lldb_disable_python = @LLDB_DISABLE_PYTHON@
+config.lldb_build_directory = "@LLDB_TEST_BUILD_DIRECTORY@"
+config.lldb_module_cache = "@LLDB_TEST_MODULE_CACHE_LLDB@"
+config.clang_module_cache = "@LLDB_TEST_MODULE_CACHE_CLANG@"
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
     config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
     config.lldb_libs_dir = config.lldb_libs_dir % lit_config.params

lldb/packages/Python/lldbsuite/test/configuration.py

 # LLDB Remote platform setting
 lldb_platform_name = None
 lldb_platform_url = None
 lldb_platform_working_dir = None
 
 # The base directory in which the tests are being built.
 test_build_dir = None
 
+# The clang module cache directory used by lldb.
+module_cache_dir = None
+
 # The only directory to scan for tests. If multiple test directories are
 # specified, and an exclusive test subdirectory is specified, the latter option
 # takes precedence.
 exclusive_test_subdir = None
 
 # Test results handling globals
 results_filename = None
 results_formatter_name = None

lldb/packages/Python/lldbsuite/test/dotest.py

 
 def get_dotest_invocation():
     return ' '.join(sys.argv)
 
 
 def is_exe(fpath):
     """Returns true if fpath is an executable."""
     if fpath == None:
         return False
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
 
 
 def which(program):
     """Returns the full path to a program; None otherwise."""
     fpath, _ = os.path.split(program)
     if fpath:
         if is_exe(program):
else:
             # 'clang' on ubuntu 14.04 is 3.4 so we try clang-3.5 first
             candidateCompilers = ['clang-3.5', 'clang', 'gcc']
             for candidate in candidateCompilers:
                 if which(candidate):
                     configuration.compiler = candidate
                     break
 
     if args.dsymutil:
         os.environ['DSYMUTIL'] = args.dsymutil
     elif platform_system == 'Darwin':
         os.environ['DSYMUTIL'] = seven.get_command_output(
             'xcrun -find -toolchain default dsymutil')
 
     if args.filecheck:
         # The lldb-dotest script produced by the CMake build passes in a path
         # to a working FileCheck binary. So does one specific Xcode project
         # target. However, when invoking dotest.py directly, a valid --filecheck
         # option needs to be given.
         configuration.filecheck = os.path.abspath(args.filecheck)
 
def parseOptionsAndInitTestdirs():
     if args.lldb_platform_name:
         configuration.lldb_platform_name = args.lldb_platform_name
     if args.lldb_platform_url:
         configuration.lldb_platform_url = args.lldb_platform_url
     if args.lldb_platform_working_dir:
         configuration.lldb_platform_working_dir = args.lldb_platform_working_dir
     if args.test_build_dir:
         configuration.test_build_dir = args.test_build_dir
+    if args.module_cache_dir:
+        configuration.module_cache_dir = args.module_cache_dir
+    else:
+        configuration.module_cache_dir = os.path.join(configuration.test_build_dir,
+                                                      'module-cache-lldb')
 
     # Gather all the dirs passed on the command line.
     if len(args.args) > 0:
         configuration.testdirs = [os.path.realpath(os.path.abspath(x)) for x in args.args]
 
     lldbtest_config.codesign_identity = args.codesign_identity
 
 
def checkLibstdcxxSupport():
     print("libstdcxx tests will not be run because: " + reason)
     configuration.skipCategories.append("libstdcxx")
 
 def canRunWatchpointTests():
     from lldbsuite.test import lldbplatformutil
 
     platform = lldbplatformutil.getPlatform()
     if platform == "netbsd":
         if os.geteuid() == 0:
             return True, "root can always write dbregs"
         try:
             output = subprocess.check_output(["/sbin/sysctl", "-n",
               "security.models.extensions.user_set_dbregs"]).decode().strip()
             if output == "1":
                 return True, "security.models.extensions.user_set_dbregs enabled"
         except subprocess.CalledProcessError:
             pass
         return False, "security.models.extensions.user_set_dbregs disabled"
     return True, "watchpoint support available"
 
 def checkWatchpointSupport():
     result, reason = canRunWatchpointTests()
     if result:
         return # watchpoints supported
     if "watchpoint" in configuration.categoriesList:
         return # watchpoint category explicitly requested, let it run.

lldb/packages/Python/lldbsuite/test/dotest_args.py

group.add_argument(
         default='lldb_codesign',
         help='The codesigning identity to use')
     group.add_argument(
         '--build-dir',
         dest='test_build_dir',
         metavar='Test build directory',
         default='lldb-test-build.noindex',
         help='The root build directory for the tests. It will be removed before running.')
+    group.add_argument(
+        '--module-cache-dir',
+        dest='module_cache_dir',
+        metavar='The clang module cache directory used by LLDB',
+        help='The clang module cache directory used by LLDB. This is not the one used by the makefiles. Defaults to <test build directory>/module-cache-lldb.')
 
     # Configuration options
     group = parser.add_argument_group('Remote platform options')
     group.add_argument(
         '--platform-name',
         dest='lldb_platform_name',
         metavar='platform-name',
         help='The name of a remote platform to use')

lldb/packages/Python/lldbsuite/test/lldbtest.py

def setUp(self):
         #import traceback
         # traceback.print_stack()
 
         # Works with the test driver to conditionally skip tests via
         # decorators.
         Base.setUp(self)
 
         # Set the clang modules cache path used by LLDB.
-        mod_cache = os.path.join(os.environ["LLDB_BUILD"], "module-cache-lldb")
-        self.runCmd('settings set symbols.clang-modules-cache-path "%s"'
-                    % mod_cache)
+        self.runCmd(
+            'settings set symbols.clang-modules-cache-path "{}"'.format(
+                configuration.module_cache_dir))
 
         for s in self.setUpCommands():
             self.runCmd(s)
 
         # Disable color.
         self.runCmd("settings set use-color false")
 
         # Make sure that a sanitizer LLDB's environment doesn't get passed on.
def runCmd(self, cmd, msg=None, check=True, trace=False, inHistory=False):
                 # For process launch, wait some time before possible next try.
                 time.sleep(self.timeWaitNextLaunch)
                 with recording(self, trace) as sbuf:
                     print("Command '" + cmd + "' failed!", file=sbuf)
 
         if check:
             output = ""
             if self.res.GetOutput():
                 output += "\nCommand output:\n" + self.res.GetOutput()
             if self.res.GetError():
                 output += "\nError output:\n" + self.res.GetError()
             if msg:
                 msg += output
             if cmd:
                 cmd += output
             self.assertTrue(self.res.Succeeded(),
                             msg if (msg) else CMD_MSG(cmd))
 
     def match(
             self,
             str,
             patterns,
             msg=None,

lldb/packages/Python/lldbsuite/test/sanity/TestModuleCacheSanity.py

+"""
+This is a sanity check that verifies that the module cache path is set
+correctly and points inside the default test build directory.
+"""
+
+from __future__ import print_function
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+
+class ModuleCacheSanityTestCase(TestBase):
+
+  mydir = TestBase.compute_mydir(__file__)
+
+  NO_DEBUG_INFO_TESTCASE = True
+
+  def test(self):
+    self.expect(
+        'settings show symbols.clang-modules-cache-path',
+        substrs=['lldb-test-build.noindex', 'module-cache-lldb'])

lldb/test/CMakeLists.txt

 # build directory.  LLDB queries Spotlight to locate .dSYM bundles
 # based on the UUID embedded in a binary, and because the UUID is a
 # hash of filename and .text section, there *will* be conflicts inside
 # the build directory.
 set(LLDB_TEST_COMMON_ARGS
   --arch=${LLDB_TEST_ARCH}
   -s
   ${CMAKE_BINARY_DIR}/lldb-test-traces
-  --build-dir
-  ${CMAKE_BINARY_DIR}/lldb-test-build.noindex
   -S nm
   -u CXXFLAGS
   -u CFLAGS
   )
 
 list(APPEND LLDB_TEST_COMMON_ARGS
   --executable ${LLDB_TEST_EXECUTABLE}
   --dsymutil ${LLDB_TEST_DSYMUTIL}

lldb/utils/lldb-dotest/lldb-dotest.in

 #!/usr/bin/env python
 import subprocess
 import sys
 
 dotest_path = '@LLDB_SOURCE_DIR@/test/dotest.py'
+build_dir = '@LLDB_TEST_BUILD_DIRECTORY@'
 dotest_args_str = '@LLDB_DOTEST_ARGS@'
 
 if __name__ == '__main__':
     wrapper_args = sys.argv[1:]
     dotest_args = dotest_args_str.split(';')
     # Build dotest.py command.
     cmd = [sys.executable, dotest_path]
     cmd.extend(dotest_args)
+    cmd.extend(['--build-dir', build_dir])
     cmd.extend(wrapper_args)
     # Invoke dotest.py and return exit code.
     print(' '.join(cmd))
     sys.exit(subprocess.call(cmd))