[lit] Allow lit config files to have a .py extension

[zturner]

Summary

Not having a .py extension breaks many python related tools, and is generally kind of obnoxious.

This is a minor quality of life improvement to allow lit config files to have .py extensions. The original filenames are still supported, now you just have the *option* of having a lit config file with a .py extension. I didn't want to get too heavy handed, so I only changed the configs in llvm/test and llvm/test/Unit

[rnk]

lit.cfg.py still isn't a valid name for a python module. I had this idea that in the future we'd import the config module directly to simplify custom test formats defined in lit configuration files, which interact badly with multiprocessing.Pool. I guess that won't work well anyway since all the config files will have the same name, so we still have to move custom test formats out into well-named python modules.

[zturner]

In D37838#870368, @rnk wrote:

lit.cfg.py still isn't a valid name for a python module. I had this idea that in the future we'd import the config module directly to simplify custom test formats defined in lit configuration files, which interact badly with multiprocessing.Pool. I guess that won't work well anyway since all the config files will have the same name, so we still have to move custom test formats out into well-named python modules.

Could we work around this by using __import__ or something or searching for a module loader with a given path, and just assigning a dynamically generated name to the module? Not trying to do anything like that with this patch by the way.

If it makes things simpler, I could call it lit_cfg.py?

[rnk]

In D37838#870372, @zturner wrote:

In D37838#870368, @rnk wrote:

lit.cfg.py still isn't a valid name for a python module. I had this idea that in the future we'd import the config module directly to simplify custom test formats defined in lit configuration files, which interact badly with multiprocessing.Pool. I guess that won't work well anyway since all the config files will have the same name, so we still have to move custom test formats out into well-named python modules.

Could we work around this by using __import__ or something or searching for a module loader with a given path, and just assigning a dynamically generated name to the module? Not trying to do anything like that with this patch by the way.

I think we could do something crazy like that.

If it makes things simpler, I could call it lit_cfg.py?

It probably won't make the import stuff simpler, so leaving it as lit.cfg.py seems more consistent with our current lit.site.cfg naming.

[dlj]

In D37838#870412, @rnk wrote:

In D37838#870372, @zturner wrote:

In D37838#870368, @rnk wrote:

lit.cfg.py still isn't a valid name for a python module. I had this idea that in the future we'd import the config module directly to simplify custom test formats defined in lit configuration files, which interact badly with multiprocessing.Pool. I guess that won't work well anyway since all the config files will have the same name, so we still have to move custom test formats out into well-named python modules.

Could we work around this by using __import__ or something or searching for a module loader with a given path, and just assigning a dynamically generated name to the module? Not trying to do anything like that with this patch by the way.

I think we could do something crazy like that.

If it makes things simpler, I could call it lit_cfg.py?

It probably won't make the import stuff simpler, so leaving it as lit.cfg.py seems more consistent with our current lit.site.cfg naming.

Just to throw my hat into the ring here...

I don't think the structure of the lit.cfg, et. al. files are terribly amenable to being imported in Python. The lit configs are written as fallthrough scripts, and probably have too many assumptions about global state and global variables to make sense to import them using Python's import mechanics. They need to work more like a pasted textual inclusion, so they can run after the basic environment is set up, but within the pre-populated namespace. They don't really work as a standalone namespaced module, and the assumed presence of globals are (I think) the main showstopper.

From that perspective, the illegal naming is almost more of a feature than a drawback. (I do think, however, that adding the extension for purposes of filename associations and editor support is reasonable.)

llvm/trunk/cmake/modules/AddLLVM.cmake

function(llvm_canonicalize_cmake_booleans)
   endforeach()
 endfunction(llvm_canonicalize_cmake_booleans)
 
 # This function provides an automatic way to 'configure'-like generate a file
 # based on a set of common and custom variables, specifically targeting the
 # variables needed for the 'lit.site.cfg' files. This function bundles the
 # common variables that any Lit instance is likely to need, and custom
 # variables can be passed in.
-function(configure_lit_site_cfg input output)
+function(configure_lit_site_cfg site_in site_out)
+  cmake_parse_arguments(ARG "" "" "MAIN_CONFIG" ${ARGN})
+
+  if ("${ARG_MAIN_CONFIG}" STREQUAL "")
+    set(ARG_MAIN_CONFIG "${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg")
+  endif()
+
   foreach(c ${LLVM_TARGETS_TO_BUILD})
     set(TARGETS_BUILT "${TARGETS_BUILT} ${c}")
   endforeach(c)
   set(TARGETS_TO_BUILD ${TARGETS_BUILT})
 
   set(SHLIBEXT "${LTDL_SHLIB_EXT}")
 
   # Configuration-time: See Unit/lit.site.cfg.in
function(configure_lit_site_cfg site_in site_out)
 
   set(HOST_OS ${CMAKE_SYSTEM_NAME})
   set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR})
 
   set(HOST_CC "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
   set(HOST_CXX "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
   set(HOST_LDFLAGS "${CMAKE_EXE_LINKER_FLAGS}")
 
-  set(LIT_SITE_CFG_IN_HEADER  "## Autogenerated from ${input}\n## Do not edit!")
+  set(LIT_SITE_CFG_IN_HEADER  "## Autogenerated from ${site_in}\n## Do not edit!")
 
   # Override config_target_triple (and the env)
   if(LLVM_TARGET_TRIPLE_ENV)
     # This is expanded into the heading.
     string(CONCAT LIT_SITE_CFG_IN_HEADER "${LIT_SITE_CFG_IN_HEADER}\n\n"
       "import os\n"
       "target_env = \"${LLVM_TARGET_TRIPLE_ENV}\"\n"
       "config.target_triple = config.environment[target_env] = os.environ.get(target_env, \"${TARGET_TRIPLE}\")\n"
       )
 
     # This is expanded to; config.target_triple = ""+config.target_triple+""
     set(TARGET_TRIPLE "\"+config.target_triple+\"")
   endif()
 
   string(CONCAT LIT_SITE_CFG_IN_FOOTER
      "import lit.llvm\n"
      "lit.llvm.initialize(lit_config, config)\n")
 
-  configure_file(${input} ${output} @ONLY)
-  get_filename_component(INPUT_DIR ${input} DIRECTORY)
-  if (EXISTS "${INPUT_DIR}/lit.cfg")
-    set(PYTHON_STATEMENT "map_config('${INPUT_DIR}/lit.cfg', '${output}')")
+  configure_file(${site_in} ${site_out} @ONLY)
+  get_filename_component(INPUT_DIR ${site_in} DIRECTORY)
+  if (EXISTS "${ARG_MAIN_CONFIG}")
+    set(PYTHON_STATEMENT "map_config('${ARG_MAIN_CONFIG}', '${site_out}')")
     get_property(LLVM_LIT_CONFIG_MAP GLOBAL PROPERTY LLVM_LIT_CONFIG_MAP)
     set(LLVM_LIT_CONFIG_MAP "${LLVM_LIT_CONFIG_MAP}\n${PYTHON_STATEMENT}")
     set_property(GLOBAL PROPERTY LLVM_LIT_CONFIG_MAP ${LLVM_LIT_CONFIG_MAP})
   endif()
 endfunction()
 
 function(dump_all_cmake_variables)
   get_cmake_property(_variableNames VARIABLES)

llvm/trunk/test/CMakeLists.txt

 llvm_canonicalize_cmake_booleans(
   LLVM_TOOL_LTO_BUILD
   HAVE_OCAMLOPT
   HAVE_OCAML_OUNIT
   LLVM_INCLUDE_GO_TESTS
   LLVM_USE_INTEL_JITEVENTS
   HAVE_LIBZ
   HAVE_LIBXAR
   LLVM_ENABLE_DIA_SDK
   LLVM_ENABLE_FFI
   BUILD_SHARED_LIBS)
 
 configure_lit_site_cfg(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
-  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
   )
 configure_lit_site_cfg(
-  ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
-  ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
+  ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg.py
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.cfg.py
   )
 
 # Don't include check-llvm into check-all without LLVM_BUILD_TOOLS.
 if(NOT LLVM_BUILD_TOOLS)
   set(EXCLUDE_FROM_ALL ON)
 endif()
 
 # Set the depends list as a variable so that it can grow conditionally.
set(LLVM_TEST_DEPENDS ${LLVM_TEST_DEPENDS}
         )
 endif()
 
 add_custom_target(llvm-test-depends DEPENDS ${LLVM_TEST_DEPENDS})
 set_target_properties(llvm-test-depends PROPERTIES FOLDER "Tests")
 
 add_lit_testsuite(check-llvm "Running the LLVM regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
-  PARAMS llvm_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
-         llvm_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
   DEPENDS ${LLVM_TEST_DEPENDS}
   )
 set_target_properties(check-llvm PROPERTIES FOLDER "Tests")
 
 add_lit_testsuites(LLVM ${CMAKE_CURRENT_SOURCE_DIR}
-  PARAMS llvm_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
-         llvm_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
   DEPENDS ${LLVM_TEST_DEPENDS}
   )
 
 # Setup a legacy alias for 'check-llvm'. This will likely change to be an
 # alias for 'check-all' at some point in the future.
 add_custom_target(check)
 add_dependencies(check check-llvm)
 set_target_properties(check PROPERTIES FOLDER "Tests")

llvm/trunk/test/Unit/lit.cfg

-# -*- Python -*-
-
-# Configuration file for the 'lit' test runner.
-
-import os
-import subprocess
-
-import lit.formats
-
-# name: The name of this test suite.
-config.name = 'LLVM-Unit'
-
-# suffixes: A list of file extensions to treat as test files.
-config.suffixes = []
-
-# is_early; Request to run this suite early.
-config.is_early = True
-
-# test_source_root: The root path where tests are located.
-# test_exec_root: The root path where tests should be run.
-config.test_exec_root = os.path.join(config.llvm_obj_root, 'unittests')
-config.test_source_root = config.test_exec_root
-
-# testFormat: The test format to use to interpret tests.
-config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, 'Tests')
-
-# Propagate the temp directory. Windows requires this because it uses \Windows\
-# if none of these are present.
-if 'TMP' in os.environ:
-    config.environment['TMP'] = os.environ['TMP']
-if 'TEMP' in os.environ:
-    config.environment['TEMP'] = os.environ['TEMP']
-
-# Propagate path to symbolizer for ASan/MSan.
-for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']:
-    if symbolizer in os.environ:
-        config.environment[symbolizer] = os.environ[symbolizer]
-
-# Win32 seeks DLLs along %PATH%.
-if sys.platform in ['win32', 'cygwin'] and os.path.isdir(config.shlibdir):
-    config.environment['PATH'] = os.path.pathsep.join((
-            config.shlibdir, config.environment['PATH']))
-
-# Win32 may use %SYSTEMDRIVE% during file system shell operations, so propogate.
-if sys.platform == 'win32' and 'SYSTEMDRIVE' in os.environ:
-    config.environment['SYSTEMDRIVE'] = os.environ['SYSTEMDRIVE']

llvm/trunk/test/Unit/lit.cfg.py

+# -*- Python -*-
+
+# Configuration file for the 'lit' test runner.
+
+import os
+import subprocess
+
+import lit.formats
+
+# name: The name of this test suite.
+config.name = 'LLVM-Unit'
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = []
+
+# is_early; Request to run this suite early.
+config.is_early = True
+
+# test_source_root: The root path where tests are located.
+# test_exec_root: The root path where tests should be run.
+config.test_exec_root = os.path.join(config.llvm_obj_root, 'unittests')
+config.test_source_root = config.test_exec_root
+
+# testFormat: The test format to use to interpret tests.
+config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, 'Tests')
+
+# Propagate the temp directory. Windows requires this because it uses \Windows\
+# if none of these are present.
+if 'TMP' in os.environ:
+    config.environment['TMP'] = os.environ['TMP']
+if 'TEMP' in os.environ:
+    config.environment['TEMP'] = os.environ['TEMP']
+
+# Propagate path to symbolizer for ASan/MSan.
+for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']:
+    if symbolizer in os.environ:
+        config.environment[symbolizer] = os.environ[symbolizer]
+
+# Win32 seeks DLLs along %PATH%.
+if sys.platform in ['win32', 'cygwin'] and os.path.isdir(config.shlibdir):
+    config.environment['PATH'] = os.path.pathsep.join((
+            config.shlibdir, config.environment['PATH']))
+
+# Win32 may use %SYSTEMDRIVE% during file system shell operations, so propogate.
+if sys.platform == 'win32' and 'SYSTEMDRIVE' in os.environ:
+    config.environment['SYSTEMDRIVE'] = os.environ['SYSTEMDRIVE']

llvm/trunk/test/Unit/lit.site.cfg.in

-@LIT_SITE_CFG_IN_HEADER@
-
-import sys
-
-config.llvm_src_root = "@LLVM_SOURCE_DIR@"
-config.llvm_obj_root = "@LLVM_BINARY_DIR@"
-config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
-config.llvm_build_mode = "@LLVM_BUILD_MODE@"
-config.enable_shared = @ENABLE_SHARED@
-config.shlibdir = "@SHLIBDIR@"
-
-# Support substitution of the tools_dir and build_mode 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_build_mode = config.llvm_build_mode % lit_config.params
-except KeyError:
-    e = sys.exc_info()[1]
-    key, = e.args
-    lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
-
-# Let the main config do the real work.
-lit_config.load_config(config, "@LLVM_SOURCE_DIR@/test/Unit/lit.cfg")

llvm/trunk/test/Unit/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+import sys
+
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_build_mode = "@LLVM_BUILD_MODE@"
+config.enable_shared = @ENABLE_SHARED@
+config.shlibdir = "@SHLIBDIR@"
+
+# Support substitution of the tools_dir and build_mode 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_build_mode = config.llvm_build_mode % lit_config.params
+except KeyError:
+    e = sys.exc_info()[1]
+    key, = e.args
+    lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@LLVM_SOURCE_DIR@/test/Unit/lit.cfg.py")

llvm/trunk/test/lit.cfg

-# -*- Python -*-
-
-# Configuration file for the 'lit' test runner.
-
-import os
-import sys
-import re
-import platform
-import subprocess
-
-import lit.util
-import lit.formats
-from lit.llvm import llvm_config
-
-# name: The name of this test suite.
-config.name = 'LLVM'
-
-# testFormat: The test format to use to interpret tests.
-config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
-
-# suffixes: A list of file extensions to treat as test files. This is overriden
-# by individual lit.local.cfg files in the test subdirectories.
-config.suffixes = ['.ll', '.c', '.cxx', '.test', '.txt', '.s', '.mir']
-
-# excludes: A list of directories to exclude from the testsuite. The 'Inputs'
-# subdirectories contain auxiliary inputs for various tests in their parent
-# directories.
-config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
-
-# test_source_root: The root path where tests are located.
-config.test_source_root = os.path.dirname(__file__)
-
-# test_exec_root: The root path where tests should be run.
-config.test_exec_root = os.path.join(config.llvm_obj_root, 'test')
-
-# Tweak the PATH to include the tools dir.
-llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
-
-# Propagate some variables from the host environment.
-llvm_config.with_system_environment(['HOME', 'INCLUDE', 'LIB', 'TMP', 'TEMP', 'ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH'])
-
-
-# Set up OCAMLPATH to include newly built OCaml libraries.
-top_ocaml_lib = os.path.join(config.llvm_lib_dir, 'ocaml')
-llvm_ocaml_lib = os.path.join(top_ocaml_lib, 'llvm')
-
-llvm_config.with_system_environment('OCAMLPATH')
-llvm_config.with_environment('OCAMLPATH', top_ocaml_lib, append_path=True)
-llvm_config.with_environment('OCAMLPATH', llvm_ocaml_lib, append_path=True)
-
-llvm_config.with_system_environment('CAML_LD_LIBRARY_PATH')
-llvm_config.with_environment('CAML_LD_LIBRARY_PATH', llvm_ocaml_lib, append_path=True)
-
-# Set up OCAMLRUNPARAM to enable backtraces in OCaml tests.
-llvm_config.with_environment('OCAMLRUNPARAM', 'b')
-
-# Provide the path to asan runtime lib 'libclang_rt.asan_osx_dynamic.dylib' if
-# available. This is darwin specific since it's currently only needed on darwin.
-def get_asan_rtlib():
-    if not "Address" in config.llvm_use_sanitizer or \
-       not "Darwin" in config.host_os or \
-       not "x86" in config.host_triple:
-        return ""
-    try:
-        import glob
-    except:
-        print("glob module not found, skipping get_asan_rtlib() lookup")
-        return ""
-    # The libclang_rt.asan_osx_dynamic.dylib path is obtained using the relative
-    # path from the host cc.
-    host_lib_dir = os.path.join(os.path.dirname(config.host_cc), "../lib")
-    asan_dylib_dir_pattern = host_lib_dir + \
-        "/clang/*/lib/darwin/libclang_rt.asan_osx_dynamic.dylib"
-    found_dylibs = glob.glob(asan_dylib_dir_pattern)
-    if len(found_dylibs) != 1:
-        return ""
-    return found_dylibs[0]
-
-lli = 'lli'
-# The target triple used by default by lli is the process target triple (some
-# triple appropriate for generating code for the current process) but because
-# we don't support COFF in MCJIT well enough for the tests, force ELF format on
-# Windows.  FIXME: the process target triple should be used here, but this is
-# difficult to obtain on Windows.
-if re.search(r'cygwin|mingw32|windows-gnu|windows-msvc|win32', config.host_triple):
-  lli += ' -mtriple='+config.host_triple+'-elf'
-config.substitutions.append( ('%lli', lli ) )
-
-# Similarly, have a macro to use llc with DWARF even when the host is win32.
-llc_dwarf = 'llc'
-if re.search(r'win32', config.target_triple):
-  llc_dwarf += ' -mtriple='+config.target_triple.replace('-win32', '-mingw32')
-config.substitutions.append( ('%llc_dwarf', llc_dwarf) )
-
-# Add site-specific substitutions.
-config.substitutions.append( ('%gold', config.gold_executable) )
-config.substitutions.append( ('%go', config.go_executable) )
-config.substitutions.append( ('%llvmshlibdir', config.llvm_shlib_dir) )
-config.substitutions.append( ('%shlibext', config.llvm_shlib_ext) )
-config.substitutions.append( ('%exeext', config.llvm_exe_ext) )
-config.substitutions.append( ('%python', config.python_executable) )
-config.substitutions.append( ('%host_cc', config.host_cc) )
-
-# Provide the path to asan runtime lib if available. On darwin, this lib needs
-# to be loaded via DYLD_INSERT_LIBRARIES before libLTO.dylib in case the files
-# to be linked contain instrumented sanitizer code.
-ld64_cmd = config.ld64_executable
-asan_rtlib = get_asan_rtlib()
-if asan_rtlib:
-  ld64_cmd = "DYLD_INSERT_LIBRARIES={} {}".format(asan_rtlib, ld64_cmd)
-config.substitutions.append( ('%ld64', ld64_cmd) )
-
-# OCaml substitutions.
-# Support tests for both native and bytecode builds.
-config.substitutions.append( ('%ocamlc',
-    "%s ocamlc -cclib -L%s %s" %
-        (config.ocamlfind_executable, config.llvm_lib_dir, config.ocaml_flags)) )
-if config.have_ocamlopt:
-    config.substitutions.append( ('%ocamlopt',
-        "%s ocamlopt -cclib -L%s -cclib -Wl,-rpath,%s %s" %
-            (config.ocamlfind_executable, config.llvm_lib_dir, config.llvm_lib_dir, config.ocaml_flags)) )
-else:
-    config.substitutions.append( ('%ocamlopt', "true" ) )
-
-# For each occurrence of an llvm tool name as its own word, replace it
-# with the full path to the build directory holding that tool.  This
-# ensures that we are testing the tools just built and not some random
-# tools that might happen to be in the user's PATH.  Thus this list
-# includes every tool placed in $(LLVM_OBJ_ROOT)/$(BuildMode)/bin
-# (llvm_tools_dir in lit parlance).
-
-# Avoid matching RUN line fragments that are actually part of
-# path names or options or whatever.
-# The regex is a pre-assertion to avoid matching a preceding
-# dot, hyphen, carat, or slash (.foo, -foo, etc.).  Some patterns
-# also have a post-assertion to not match a trailing hyphen (foo-).
-NOJUNK = r"(?<!\.|-|\^|/|<)"
-
-
-def find_tool_substitution(pattern):
-    # Extract the tool name from the pattern.  This relies on the tool
-    # name being surrounded by \b word match operators.  If the
-    # pattern starts with "| ", include it in the string to be
-    # substituted.
-    tool_match = re.match(r"^(\\)?((\| )?)\W+b([0-9A-Za-z-_]+)\\b\W*$",
-                          pattern)
-    tool_pipe = tool_match.group(2)
-    tool_name = tool_match.group(4)
-    # Did the user specify the tool path + arguments? This allows things like
-    # llvm-lit "-Dllc=llc -enable-misched -verify-machineinstrs"
-    tool_path = lit_config.params.get(tool_name)
-    if tool_path is None:
-        tool_path = lit.util.which(tool_name, config.llvm_tools_dir)
-        if tool_path is None:
-            return tool_name, tool_path, tool_pipe
-    if (tool_name == "llc" and
-       'LLVM_ENABLE_MACHINE_VERIFIER' in os.environ and
-       os.environ['LLVM_ENABLE_MACHINE_VERIFIER'] == "1"):
-        tool_path += " -verify-machineinstrs"
-    if (tool_name == "llvm-go"):
-        tool_path += " go=" + config.go_executable
-    return tool_name, tool_path, tool_pipe
-
-
-for pattern in [r"\bbugpoint\b(?!-)",
-                NOJUNK + r"\bllc\b",
-                r"\blli\b",
-                r"\bllvm-ar\b",
-                r"\bllvm-as\b",
-                r"\bllvm-bcanalyzer\b",
-                r"\bllvm-config\b",
-                r"\bllvm-cov\b",
-                r"\bllvm-cxxdump\b",
-                r"\bllvm-cvtres\b",
-                r"\bllvm-diff\b",
-                r"\bllvm-dis\b",
-                r"\bllvm-dsymutil\b",
-                r"\bllvm-dwarfdump\b",
-                r"\bllvm-extract\b",
-                r"\bllvm-isel-fuzzer\b",
-                r"\bllvm-lib\b",
-                r"\bllvm-link\b",
-                r"\bllvm-lto\b",
-                r"\bllvm-lto2\b",
-                r"\bllvm-mc\b",
-                r"\bllvm-mcmarkup\b",
-                r"\bllvm-modextract\b",
-                r"\bllvm-nm\b",
-                r"\bllvm-objcopy\b",
-                r"\bllvm-objdump\b",
-                r"\bllvm-pdbutil\b",
-                r"\bllvm-profdata\b",
-                r"\bllvm-ranlib\b",
-                r"\bllvm-readobj\b",
-                r"\bllvm-rtdyld\b",
-                r"\bllvm-size\b",
-                r"\bllvm-split\b",
-                r"\bllvm-strings\b",
-                r"\bllvm-tblgen\b",
-                r"\bllvm-c-test\b",
-                r"\bllvm-cxxfilt\b",
-                r"\bllvm-xray\b",
-                NOJUNK + r"\bllvm-symbolizer\b",
-                NOJUNK + r"\bopt\b",
-                r"\bFileCheck\b",
-                r"\bobj2yaml\b",
-                NOJUNK + r"\bsancov\b",
-                NOJUNK + r"\bsanstats\b",
-                r"\byaml2obj\b",
-                r"\byaml-bench\b",
-                r"\bverify-uselistorder\b",
-                # Handle these specially as they are strings searched
-                # for during testing.
-                r"\| \bcount\b",
-                r"\| \bnot\b"]:
-    tool_name, tool_path, tool_pipe = find_tool_substitution(pattern)
-    if not tool_path:
-        # Warn, but still provide a substitution.
-        lit_config.note('Did not find ' + tool_name + ' in ' + config.llvm_tools_dir)
-        tool_path = config.llvm_tools_dir + '/' + tool_name
-    config.substitutions.append((pattern, tool_pipe + tool_path))
-
-# For tools that are optional depending on the config, we won't warn
-# if they're missing.
-for pattern in [r"\bllvm-go\b",
-                r"\bllvm-mt\b",
-                r"\bKaleidoscope-Ch3\b",
-                r"\bKaleidoscope-Ch4\b",
-                r"\bKaleidoscope-Ch5\b",
-                r"\bKaleidoscope-Ch6\b",
-                r"\bKaleidoscope-Ch7\b",
-                r"\bKaleidoscope-Ch8\b"]:
-    tool_name, tool_path, tool_pipe = find_tool_substitution(pattern)
-    if not tool_path:
-        # Provide a substitution anyway, for the sake of consistent errors.
-        tool_path = config.llvm_tools_dir + '/' + tool_name
-    config.substitutions.append((pattern, tool_pipe + tool_path))
-
-
-### Targets
-
-config.targets = frozenset(config.targets_to_build.split())
-
-for arch in config.targets_to_build.split():
-    config.available_features.add(arch.lower() + '-registered-target')
-
-### Features
-
-# Others/can-execute.txt
-if sys.platform not in ['win32']:
-    config.available_features.add('can-execute')
-    config.available_features.add('not_COFF')
-
-# Loadable module
-# FIXME: This should be supplied by Makefile or autoconf.
-if sys.platform in ['win32', 'cygwin']:
-    loadable_module = (config.enable_shared == 1)
-else:
-    loadable_module = True
-
-if loadable_module:
-    config.available_features.add('loadable_module')
-
-# Static libraries are not built if BUILD_SHARED_LIBS is ON.
-if not config.build_shared_libs:
-    config.available_features.add("static-libs")
-
-# Direct object generation
-if not 'hexagon' in config.target_triple:
-    config.available_features.add("object-emission")
-
-# LLVM can be configured with an empty default triple
-# Some tests are "generic" and require a valid default triple
-if config.target_triple:
-    config.available_features.add("default_triple")
-
-import subprocess
-
-def have_ld_plugin_support():
-    if not os.path.exists(os.path.join(config.llvm_shlib_dir, 'LLVMgold.so')):
-        return False
-
-    ld_cmd = subprocess.Popen([config.gold_executable, '--help'], stdout = subprocess.PIPE, env={'LANG': 'C'})
-    ld_out = ld_cmd.stdout.read().decode()
-    ld_cmd.wait()
-
-    if not '-plugin' in ld_out:
-        return False
-
-    # check that the used emulations are supported.
-    emu_line = [l for l in ld_out.split('\n') if 'supported emulations' in l]
-    if len(emu_line) != 1:
-        return False
-    emu_line = emu_line[0]
-    fields = emu_line.split(':')
-    if len(fields) != 3:
-        return False
-    emulations = fields[2].split()
-    if 'elf_x86_64' not in emulations:
-        return False
-    if 'elf32ppc' in emulations:
-        config.available_features.add('ld_emu_elf32ppc')
-
-    ld_version = subprocess.Popen([config.gold_executable, '--version'], stdout = subprocess.PIPE, env={'LANG': 'C'})
-    if not 'GNU gold' in ld_version.stdout.read().decode():
-        return False
-    ld_version.wait()
-
-    return True
-
-if have_ld_plugin_support():
-    config.available_features.add('ld_plugin')
-
-def have_ld64_plugin_support():
-    if not config.llvm_tool_lto_build or config.ld64_executable == '':
-        return False
-
-    ld_cmd = subprocess.Popen([config.ld64_executable, '-v'], stderr = subprocess.PIPE)
-    ld_out = ld_cmd.stderr.read().decode()
-    ld_cmd.wait()
-
-    if 'ld64' not in ld_out or 'LTO' not in ld_out:
-        return False
-
-    return True
-
-if have_ld64_plugin_support():
-    config.available_features.add('ld64_plugin')
-
-# Ask llvm-config about asserts and global-isel.
-llvm_config.feature_config(
-  [('--assertion-mode', {'ON' : 'asserts'}),
-   ('--has-global-isel', {'ON' : 'global-isel'})])
-
-if 'darwin' == sys.platform:
-    try:
-        sysctl_cmd = subprocess.Popen(['sysctl', 'hw.optional.fma'],
-                                    stdout = subprocess.PIPE)
-    except OSError:
-        print("Could not exec sysctl")
-    result = sysctl_cmd.stdout.read().decode('ascii')
-    if -1 != result.find("hw.optional.fma: 1"):
-        config.available_features.add('fma3')
-    sysctl_cmd.wait()
-
-# .debug_frame is not emitted for targeting Windows x64.
-if not re.match(r'^x86_64.*-(mingw32|windows-gnu|win32)', config.target_triple):
-    config.available_features.add('debug_frame')
-
-if config.have_libxar:
-    config.available_features.add('xar')
-
-if config.llvm_libxml2_enabled == "1":
-    config.available_features.add('libxml2')

llvm/trunk/test/lit.cfg.py

+# -*- Python -*-
+
+# Configuration file for the 'lit' test runner.
+
+import os
+import sys
+import re
+import platform
+import subprocess
+
+import lit.util
+import lit.formats
+from lit.llvm import llvm_config
+
+# name: The name of this test suite.
+config.name = 'LLVM'
+
+# testFormat: The test format to use to interpret tests.
+config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
+
+# suffixes: A list of file extensions to treat as test files. This is overriden
+# by individual lit.local.cfg files in the test subdirectories.
+config.suffixes = ['.ll', '.c', '.cxx', '.test', '.txt', '.s', '.mir']
+
+# excludes: A list of directories to exclude from the testsuite. The 'Inputs'
+# subdirectories contain auxiliary inputs for various tests in their parent
+# directories.
+config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
+
+# test_source_root: The root path where tests are located.
+config.test_source_root = os.path.dirname(__file__)
+
+# test_exec_root: The root path where tests should be run.
+config.test_exec_root = os.path.join(config.llvm_obj_root, 'test')
+
+# Tweak the PATH to include the tools dir.
+llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
+
+# Propagate some variables from the host environment.
+llvm_config.with_system_environment(['HOME', 'INCLUDE', 'LIB', 'TMP', 'TEMP', 'ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH'])
+
+
+# Set up OCAMLPATH to include newly built OCaml libraries.
+top_ocaml_lib = os.path.join(config.llvm_lib_dir, 'ocaml')
+llvm_ocaml_lib = os.path.join(top_ocaml_lib, 'llvm')
+
+llvm_config.with_system_environment('OCAMLPATH')
+llvm_config.with_environment('OCAMLPATH', top_ocaml_lib, append_path=True)
+llvm_config.with_environment('OCAMLPATH', llvm_ocaml_lib, append_path=True)
+
+llvm_config.with_system_environment('CAML_LD_LIBRARY_PATH')
+llvm_config.with_environment('CAML_LD_LIBRARY_PATH', llvm_ocaml_lib, append_path=True)
+
+# Set up OCAMLRUNPARAM to enable backtraces in OCaml tests.
+llvm_config.with_environment('OCAMLRUNPARAM', 'b')
+
+# Provide the path to asan runtime lib 'libclang_rt.asan_osx_dynamic.dylib' if
+# available. This is darwin specific since it's currently only needed on darwin.
+def get_asan_rtlib():
+    if not "Address" in config.llvm_use_sanitizer or \
+       not "Darwin" in config.host_os or \
+       not "x86" in config.host_triple:
+        return ""
+    try:
+        import glob
+    except:
+        print("glob module not found, skipping get_asan_rtlib() lookup")
+        return ""
+    # The libclang_rt.asan_osx_dynamic.dylib path is obtained using the relative
+    # path from the host cc.
+    host_lib_dir = os.path.join(os.path.dirname(config.host_cc), "../lib")
+    asan_dylib_dir_pattern = host_lib_dir + \
+        "/clang/*/lib/darwin/libclang_rt.asan_osx_dynamic.dylib"
+    found_dylibs = glob.glob(asan_dylib_dir_pattern)
+    if len(found_dylibs) != 1:
+        return ""
+    return found_dylibs[0]
+
+lli = 'lli'
+# The target triple used by default by lli is the process target triple (some
+# triple appropriate for generating code for the current process) but because
+# we don't support COFF in MCJIT well enough for the tests, force ELF format on
+# Windows.  FIXME: the process target triple should be used here, but this is
+# difficult to obtain on Windows.
+if re.search(r'cygwin|mingw32|windows-gnu|windows-msvc|win32', config.host_triple):
+  lli += ' -mtriple='+config.host_triple+'-elf'
+config.substitutions.append( ('%lli', lli ) )
+
+# Similarly, have a macro to use llc with DWARF even when the host is win32.
+llc_dwarf = 'llc'
+if re.search(r'win32', config.target_triple):
+  llc_dwarf += ' -mtriple='+config.target_triple.replace('-win32', '-mingw32')
+config.substitutions.append( ('%llc_dwarf', llc_dwarf) )
+
+# Add site-specific substitutions.
+config.substitutions.append( ('%gold', config.gold_executable) )
+config.substitutions.append( ('%go', config.go_executable) )
+config.substitutions.append( ('%llvmshlibdir', config.llvm_shlib_dir) )
+config.substitutions.append( ('%shlibext', config.llvm_shlib_ext) )
+config.substitutions.append( ('%exeext', config.llvm_exe_ext) )
+config.substitutions.append( ('%python', config.python_executable) )
+config.substitutions.append( ('%host_cc', config.host_cc) )
+
+# Provide the path to asan runtime lib if available. On darwin, this lib needs
+# to be loaded via DYLD_INSERT_LIBRARIES before libLTO.dylib in case the files
+# to be linked contain instrumented sanitizer code.
+ld64_cmd = config.ld64_executable
+asan_rtlib = get_asan_rtlib()
+if asan_rtlib:
+  ld64_cmd = "DYLD_INSERT_LIBRARIES={} {}".format(asan_rtlib, ld64_cmd)
+config.substitutions.append( ('%ld64', ld64_cmd) )
+
+# OCaml substitutions.
+# Support tests for both native and bytecode builds.
+config.substitutions.append( ('%ocamlc',
+    "%s ocamlc -cclib -L%s %s" %
+        (config.ocamlfind_executable, config.llvm_lib_dir, config.ocaml_flags)) )
+if config.have_ocamlopt:
+    config.substitutions.append( ('%ocamlopt',
+        "%s ocamlopt -cclib -L%s -cclib -Wl,-rpath,%s %s" %
+            (config.ocamlfind_executable, config.llvm_lib_dir, config.llvm_lib_dir, config.ocaml_flags)) )
+else:
+    config.substitutions.append( ('%ocamlopt', "true" ) )
+
+# For each occurrence of an llvm tool name as its own word, replace it
+# with the full path to the build directory holding that tool.  This
+# ensures that we are testing the tools just built and not some random
+# tools that might happen to be in the user's PATH.  Thus this list
+# includes every tool placed in $(LLVM_OBJ_ROOT)/$(BuildMode)/bin
+# (llvm_tools_dir in lit parlance).
+
+# Avoid matching RUN line fragments that are actually part of
+# path names or options or whatever.
+# The regex is a pre-assertion to avoid matching a preceding
+# dot, hyphen, carat, or slash (.foo, -foo, etc.).  Some patterns
+# also have a post-assertion to not match a trailing hyphen (foo-).
+NOJUNK = r"(?<!\.|-|\^|/|<)"
+
+
+def find_tool_substitution(pattern):
+    # Extract the tool name from the pattern.  This relies on the tool
+    # name being surrounded by \b word match operators.  If the
+    # pattern starts with "| ", include it in the string to be
+    # substituted.
+    tool_match = re.match(r"^(\\)?((\| )?)\W+b([0-9A-Za-z-_]+)\\b\W*$",
+                          pattern)
+    tool_pipe = tool_match.group(2)
+    tool_name = tool_match.group(4)
+    # Did the user specify the tool path + arguments? This allows things like
+    # llvm-lit "-Dllc=llc -enable-misched -verify-machineinstrs"
+    tool_path = lit_config.params.get(tool_name)
+    if tool_path is None:
+        tool_path = lit.util.which(tool_name, config.llvm_tools_dir)
+        if tool_path is None:
+            return tool_name, tool_path, tool_pipe
+    if (tool_name == "llc" and
+       'LLVM_ENABLE_MACHINE_VERIFIER' in os.environ and
+       os.environ['LLVM_ENABLE_MACHINE_VERIFIER'] == "1"):
+        tool_path += " -verify-machineinstrs"
+    if (tool_name == "llvm-go"):
+        tool_path += " go=" + config.go_executable
+    return tool_name, tool_path, tool_pipe
+
+
+for pattern in [r"\bbugpoint\b(?!-)",
+                NOJUNK + r"\bllc\b",
+                r"\blli\b",
+                r"\bllvm-ar\b",
+                r"\bllvm-as\b",
+                r"\bllvm-bcanalyzer\b",
+                r"\bllvm-config\b",
+                r"\bllvm-cov\b",
+                r"\bllvm-cxxdump\b",
+                r"\bllvm-cvtres\b",
+                r"\bllvm-diff\b",
+                r"\bllvm-dis\b",
+                r"\bllvm-dsymutil\b",
+                r"\bllvm-dwarfdump\b",
+                r"\bllvm-extract\b",
+                r"\bllvm-isel-fuzzer\b",
+                r"\bllvm-lib\b",
+                r"\bllvm-link\b",
+                r"\bllvm-lto\b",
+                r"\bllvm-lto2\b",
+                r"\bllvm-mc\b",
+                r"\bllvm-mcmarkup\b",
+                r"\bllvm-modextract\b",
+                r"\bllvm-nm\b",
+                r"\bllvm-objcopy\b",
+                r"\bllvm-objdump\b",
+                r"\bllvm-pdbutil\b",
+                r"\bllvm-profdata\b",
+                r"\bllvm-ranlib\b",
+                r"\bllvm-readobj\b",
+                r"\bllvm-rtdyld\b",
+                r"\bllvm-size\b",
+                r"\bllvm-split\b",
+                r"\bllvm-strings\b",
+                r"\bllvm-tblgen\b",
+                r"\bllvm-c-test\b",
+                r"\bllvm-cxxfilt\b",
+                r"\bllvm-xray\b",
+                NOJUNK + r"\bllvm-symbolizer\b",
+                NOJUNK + r"\bopt\b",
+                r"\bFileCheck\b",
+                r"\bobj2yaml\b",
+                NOJUNK + r"\bsancov\b",
+                NOJUNK + r"\bsanstats\b",
+                r"\byaml2obj\b",
+                r"\byaml-bench\b",
+                r"\bverify-uselistorder\b",
+                # Handle these specially as they are strings searched
+                # for during testing.
+                r"\| \bcount\b",
+                r"\| \bnot\b"]:
+    tool_name, tool_path, tool_pipe = find_tool_substitution(pattern)
+    if not tool_path:
+        # Warn, but still provide a substitution.
+        lit_config.note('Did not find ' + tool_name + ' in ' + config.llvm_tools_dir)
+        tool_path = config.llvm_tools_dir + '/' + tool_name
+    config.substitutions.append((pattern, tool_pipe + tool_path))
+
+# For tools that are optional depending on the config, we won't warn
+# if they're missing.
+for pattern in [r"\bllvm-go\b",
+                r"\bllvm-mt\b",
+                r"\bKaleidoscope-Ch3\b",
+                r"\bKaleidoscope-Ch4\b",
+                r"\bKaleidoscope-Ch5\b",
+                r"\bKaleidoscope-Ch6\b",
+                r"\bKaleidoscope-Ch7\b",
+                r"\bKaleidoscope-Ch8\b"]:
+    tool_name, tool_path, tool_pipe = find_tool_substitution(pattern)
+    if not tool_path:
+        # Provide a substitution anyway, for the sake of consistent errors.
+        tool_path = config.llvm_tools_dir + '/' + tool_name
+    config.substitutions.append((pattern, tool_pipe + tool_path))
+
+
+### Targets
+
+config.targets = frozenset(config.targets_to_build.split())
+
+for arch in config.targets_to_build.split():
+    config.available_features.add(arch.lower() + '-registered-target')
+
+### Features
+
+# Others/can-execute.txt
+if sys.platform not in ['win32']:
+    config.available_features.add('can-execute')
+    config.available_features.add('not_COFF')
+
+# Loadable module
+# FIXME: This should be supplied by Makefile or autoconf.
+if sys.platform in ['win32', 'cygwin']:
+    loadable_module = (config.enable_shared == 1)
+else:
+    loadable_module = True
+
+if loadable_module:
+    config.available_features.add('loadable_module')
+
+# Static libraries are not built if BUILD_SHARED_LIBS is ON.
+if not config.build_shared_libs:
+    config.available_features.add("static-libs")
+
+# Direct object generation
+if not 'hexagon' in config.target_triple:
+    config.available_features.add("object-emission")
+
+# LLVM can be configured with an empty default triple
+# Some tests are "generic" and require a valid default triple
+if config.target_triple:
+    config.available_features.add("default_triple")
+
+import subprocess
+
+def have_ld_plugin_support():
+    if not os.path.exists(os.path.join(config.llvm_shlib_dir, 'LLVMgold.so')):
+        return False
+
+    ld_cmd = subprocess.Popen([config.gold_executable, '--help'], stdout = subprocess.PIPE, env={'LANG': 'C'})
+    ld_out = ld_cmd.stdout.read().decode()
+    ld_cmd.wait()
+
+    if not '-plugin' in ld_out:
+        return False
+
+    # check that the used emulations are supported.
+    emu_line = [l for l in ld_out.split('\n') if 'supported emulations' in l]
+    if len(emu_line) != 1:
+        return False
+    emu_line = emu_line[0]
+    fields = emu_line.split(':')
+    if len(fields) != 3:
+        return False
+    emulations = fields[2].split()
+    if 'elf_x86_64' not in emulations:
+        return False
+    if 'elf32ppc' in emulations:
+        config.available_features.add('ld_emu_elf32ppc')
+
+    ld_version = subprocess.Popen([config.gold_executable, '--version'], stdout = subprocess.PIPE, env={'LANG': 'C'})
+    if not 'GNU gold' in ld_version.stdout.read().decode():
+        return False
+    ld_version.wait()
+
+    return True
+
+if have_ld_plugin_support():
+    config.available_features.add('ld_plugin')
+
+def have_ld64_plugin_support():
+    if not config.llvm_tool_lto_build or config.ld64_executable == '':
+        return False
+
+    ld_cmd = subprocess.Popen([config.ld64_executable, '-v'], stderr = subprocess.PIPE)
+    ld_out = ld_cmd.stderr.read().decode()
+    ld_cmd.wait()
+
+    if 'ld64' not in ld_out or 'LTO' not in ld_out:
+        return False
+
+    return True
+
+if have_ld64_plugin_support():
+    config.available_features.add('ld64_plugin')
+
+# Ask llvm-config about asserts and global-isel.
+llvm_config.feature_config(
+  [('--assertion-mode', {'ON' : 'asserts'}),
+   ('--has-global-isel', {'ON' : 'global-isel'})])
+
+if 'darwin' == sys.platform:
+    try:
+        sysctl_cmd = subprocess.Popen(['sysctl', 'hw.optional.fma'],
+                                    stdout = subprocess.PIPE)
+    except OSError:
+        print("Could not exec sysctl")
+    result = sysctl_cmd.stdout.read().decode('ascii')
+    if -1 != result.find("hw.optional.fma: 1"):
+        config.available_features.add('fma3')
+    sysctl_cmd.wait()
+
+# .debug_frame is not emitted for targeting Windows x64.
+if not re.match(r'^x86_64.*-(mingw32|windows-gnu|win32)', config.target_triple):
+    config.available_features.add('debug_frame')
+
+if config.have_libxar:
+    config.available_features.add('xar')
+
+if config.llvm_libxml2_enabled == "1":
+    config.available_features.add('libxml2')

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

-@LIT_SITE_CFG_IN_HEADER@
-
-import sys
-
-config.host_triple = "@LLVM_HOST_TRIPLE@"
-config.target_triple = "@TARGET_TRIPLE@"
-config.llvm_src_root = "@LLVM_SOURCE_DIR@"
-config.llvm_obj_root = "@LLVM_BINARY_DIR@"
-config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
-config.llvm_lib_dir = "@LLVM_LIBRARY_DIR@"
-config.llvm_shlib_dir = "@SHLIBDIR@"
-config.llvm_shlib_ext = "@SHLIBEXT@"
-config.llvm_exe_ext = "@EXEEXT@"
-config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
-config.python_executable = "@PYTHON_EXECUTABLE@"
-config.gold_executable = "@GOLD_EXECUTABLE@"
-config.ld64_executable = "@LD64_EXECUTABLE@"
-config.llvm_tool_lto_build = @LLVM_TOOL_LTO_BUILD@
-config.ocamlfind_executable = "@OCAMLFIND@"
-config.have_ocamlopt = @HAVE_OCAMLOPT@
-config.have_ocaml_ounit = @HAVE_OCAML_OUNIT@
-config.ocaml_flags = "@OCAMLFLAGS@"
-config.include_go_tests = @LLVM_INCLUDE_GO_TESTS@
-config.go_executable = "@GO_EXECUTABLE@"
-config.enable_shared = @ENABLE_SHARED@
-config.enable_assertions = @ENABLE_ASSERTIONS@
-config.enable_abi_breaking_checks = "@LLVM_ENABLE_ABI_BREAKING_CHECKS@"
-config.targets_to_build = "@TARGETS_TO_BUILD@"
-config.native_target = "@LLVM_NATIVE_ARCH@"
-config.llvm_bindings = "@LLVM_BINDINGS@".split(' ')
-config.host_os = "@HOST_OS@"
-config.host_arch = "@HOST_ARCH@"
-config.host_cc = "@HOST_CC@"
-config.host_cxx = "@HOST_CXX@"
-config.host_ldflags = "@HOST_LDFLAGS@"
-config.llvm_use_intel_jitevents = @LLVM_USE_INTEL_JITEVENTS@
-config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
-config.have_zlib = @HAVE_LIBZ@
-config.have_libxar = @HAVE_LIBXAR@
-config.have_dia_sdk = @LLVM_ENABLE_DIA_SDK@
-config.enable_ffi = @LLVM_ENABLE_FFI@
-config.build_shared_libs = @BUILD_SHARED_LIBS@
-config.llvm_libxml2_enabled = "@LLVM_LIBXML2_ENABLED@"
-
-# Support substitution of the tools_dir 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_shlib_dir = config.llvm_shlib_dir % lit_config.params
-except KeyError:
-    e = sys.exc_info()[1]
-    key, = e.args
-    lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
-
-@LIT_SITE_CFG_IN_FOOTER@
-
-# Let the main config do the real work.
-lit_config.load_config(config, "@LLVM_SOURCE_DIR@/test/lit.cfg")

llvm/trunk/test/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+import sys
+
+config.host_triple = "@LLVM_HOST_TRIPLE@"
+config.target_triple = "@TARGET_TRIPLE@"
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_lib_dir = "@LLVM_LIBRARY_DIR@"
+config.llvm_shlib_dir = "@SHLIBDIR@"
+config.llvm_shlib_ext = "@SHLIBEXT@"
+config.llvm_exe_ext = "@EXEEXT@"
+config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
+config.python_executable = "@PYTHON_EXECUTABLE@"
+config.gold_executable = "@GOLD_EXECUTABLE@"
+config.ld64_executable = "@LD64_EXECUTABLE@"
+config.llvm_tool_lto_build = @LLVM_TOOL_LTO_BUILD@
+config.ocamlfind_executable = "@OCAMLFIND@"
+config.have_ocamlopt = @HAVE_OCAMLOPT@
+config.have_ocaml_ounit = @HAVE_OCAML_OUNIT@
+config.ocaml_flags = "@OCAMLFLAGS@"
+config.include_go_tests = @LLVM_INCLUDE_GO_TESTS@
+config.go_executable = "@GO_EXECUTABLE@"
+config.enable_shared = @ENABLE_SHARED@
+config.enable_assertions = @ENABLE_ASSERTIONS@
+config.enable_abi_breaking_checks = "@LLVM_ENABLE_ABI_BREAKING_CHECKS@"
+config.targets_to_build = "@TARGETS_TO_BUILD@"
+config.native_target = "@LLVM_NATIVE_ARCH@"
+config.llvm_bindings = "@LLVM_BINDINGS@".split(' ')
+config.host_os = "@HOST_OS@"
+config.host_arch = "@HOST_ARCH@"
+config.host_cc = "@HOST_CC@"
+config.host_cxx = "@HOST_CXX@"
+config.host_ldflags = "@HOST_LDFLAGS@"
+config.llvm_use_intel_jitevents = @LLVM_USE_INTEL_JITEVENTS@
+config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
+config.have_zlib = @HAVE_LIBZ@
+config.have_libxar = @HAVE_LIBXAR@
+config.have_dia_sdk = @LLVM_ENABLE_DIA_SDK@
+config.enable_ffi = @LLVM_ENABLE_FFI@
+config.build_shared_libs = @BUILD_SHARED_LIBS@
+config.llvm_libxml2_enabled = "@LLVM_LIBXML2_ENABLED@"
+
+# Support substitution of the tools_dir 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_shlib_dir = config.llvm_shlib_dir % lit_config.params
+except KeyError:
+    e = sys.exc_info()[1]
+    key, = e.args
+    lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
+
+@LIT_SITE_CFG_IN_FOOTER@
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@LLVM_SOURCE_DIR@/test/lit.cfg.py")

llvm/trunk/utils/lit/lit/LitConfig.py

def __init__(self, progname, path, quiet,
         self.debug = debug
         self.singleProcess = singleProcess
         self.isWindows = bool(isWindows)
         self.params = dict(params)
         self.bashPath = None
 
         # Configuration files to look for when discovering test suites.
         self.config_prefix = config_prefix or 'lit'
-        self.config_name = '%s.cfg' % (self.config_prefix,)
-        self.site_config_name = '%s.site.cfg' % (self.config_prefix,)
-        self.local_config_name = '%s.local.cfg' % (self.config_prefix,)
+        self.suffixes = ['cfg.py', 'cfg']
+        self.config_names = ['%s.%s' % (self.config_prefix,x) for x in self.suffixes]
+        self.site_config_names = ['%s.site.%s' % (self.config_prefix,x) for x in self.suffixes]
+        self.local_config_names = ['%s.local.%s' % (self.config_prefix,x) for x in self.suffixes]
 
         self.numErrors = 0
         self.numWarnings = 0
 
         self.valgrindArgs = []
         if self.useValgrind:
             self.valgrindArgs = ['valgrind', '-q', '--run-libc-freeres=no',
                                  '--tool=memcheck', '--trace-children=yes',

llvm/trunk/utils/lit/lit/discovery.py

 """
 Test discovery functions.
 """
 
 import copy
 import os
 import sys
 
 import lit.run
 from lit.TestingConfig import TestingConfig
 from lit import LitConfig, Test
 
+def chooseConfigFileFromDir(dir, config_names):
+    for name in config_names:
+        p = os.path.join(dir, name)
+        if os.path.exists(p):
+            return p
+    return None
+
 def dirContainsTestSuite(path, lit_config):
-    cfgpath = os.path.join(path, lit_config.site_config_name)
-    if os.path.exists(cfgpath):
-        return cfgpath
-    cfgpath = os.path.join(path, lit_config.config_name)
-    if os.path.exists(cfgpath):
-        return cfgpath
+    cfgpath = chooseConfigFileFromDir(path, lit_config.site_config_names)
+    if not cfgpath:
+        cfgpath = chooseConfigFileFromDir(path, lit_config.config_names)
 
 def getTestSuite(item, litConfig, cache):
     """getTestSuite(item, litConfig, cache) -> (suite, relative_path)
 
     Find the test suite containing @arg item.
 
     @retval (None, ...) - Indicates no test suite contains @arg item.
     @retval (suite, relative_path) - The suite that @arg item is in, and its
def search1(path_in_suite):
         # Get the parent config.
         if not path_in_suite:
             parent = ts.config
         else:
             parent = search(path_in_suite[:-1])
 
         # Check if there is a local configuration file.
         source_path = ts.getSourcePath(path_in_suite)
-        cfgpath = os.path.join(source_path, litConfig.local_config_name)
+        cfgpath = chooseConfigFileFromDir(source_path, litConfig.local_config_names)
 
         # If not, just reuse the parent config.
-        if not os.path.exists(cfgpath):
+        if not cfgpath:
             return parent
 
         # Otherwise, copy the current config and load the local configuration
         # file into it.
         config = copy.deepcopy(parent)
         if litConfig.debug:
             litConfig.note('loading local config %r' % cfgpath)
         config.load_from_path(cfgpath, litConfig)

llvm/trunk/utils/lit/tests/Inputs/py-config-discovery/lit.site.cfg.py

+# Load the discovery suite, but with a separate exec root.
+import os
+config.test_exec_root = os.path.dirname(__file__)
+config.test_source_root = os.path.join(os.path.dirname(config.test_exec_root), "discovery")
+lit_config.load_config(config, os.path.join(config.test_source_root, "lit.cfg"))

llvm/trunk/utils/lit/tests/discovery.py

 # RUN:     %{inputs}/discovery/subsuite/test-one.txt \
 # RUN:   -j 1 --show-tests --show-suites -v > %t.out
 # RUN: FileCheck --check-prefix=CHECK-EXACT-TEST < %t.out %s
 #
 # CHECK-EXACT-TEST: -- Available Tests --
 # CHECK-EXACT-TEST: sub-suite :: test-one
 # CHECK-EXACT-TEST: top-level-suite :: subdir/test-three
 
+# Check discovery when config files end in .py
+# RUN: %{lit} %{inputs}/py-config-discovery \
+# RUN:   -j 1 --debug --show-tests --show-suites \
+# RUN:   -v > %t.out 2> %t.err
+# RUN: FileCheck --check-prefix=CHECK-PYCONFIG-OUT < %t.out %s
+# RUN: FileCheck --check-prefix=CHECK-PYCONFIG-ERR < %t.err %s
+#
+# CHECK-PYCONFIG-ERR: loading suite config '{{.*(/|\\\\)py-config-discovery(/|\\\\)lit.site.cfg.py}}'
+# CHECK-PYCONFIG-ERR: load_config from '{{.*(/|\\\\)discovery(/|\\\\)lit.cfg}}'
+# CHECK-PYCONFIG-ERR: loaded config '{{.*(/|\\\\)discovery(/|\\\\)lit.cfg}}'
+# CHECK-PYCONFIG-ERR: loaded config '{{.*(/|\\\\)py-config-discovery(/|\\\\)lit.site.cfg.py}}'
+# CHECK-PYCONFIG-ERR-DAG: loading suite config '{{.*(/|\\\\)discovery(/|\\\\)subsuite(/|\\\\)lit.cfg}}'
+# CHECK-PYCONFIG-ERR-DAG: loading local config '{{.*(/|\\\\)discovery(/|\\\\)subdir(/|\\\\)lit.local.cfg}}'
+#
+# CHECK-PYCONFIG-OUT: -- Test Suites --
+# CHECK-PYCONFIG-OUT:   sub-suite - 2 tests
+# CHECK-PYCONFIG-OUT:     Source Root: {{.*[/\\]discovery[/\\]subsuite$}}
+# CHECK-PYCONFIG-OUT:     Exec Root  : {{.*[/\\]discovery[/\\]subsuite$}}
+# CHECK-PYCONFIG-OUT:   top-level-suite - 3 tests
+# CHECK-PYCONFIG-OUT:     Source Root: {{.*[/\\]discovery$}}
+# CHECK-PYCONFIG-OUT:     Exec Root  : {{.*[/\\]py-config-discovery$}}
+#
+# CHECK-PYCONFIG-OUT: -- Available Tests --
+# CHECK-PYCONFIG-OUT: sub-suite :: test-one
+# CHECK-PYCONFIG-OUT: sub-suite :: test-two
+# CHECK-PYCONFIG-OUT: top-level-suite :: subdir/test-three
+# CHECK-PYCONFIG-OUT: top-level-suite :: test-one
+# CHECK-PYCONFIG-OUT: top-level-suite :: test-two
 
 # Check discovery when using an exec path.
 #
 # RUN: %{lit} %{inputs}/exec-discovery \
 # RUN:   -j 1 --debug --show-tests --show-suites \
 # RUN:   -v > %t.out 2> %t.err
 # RUN: FileCheck --check-prefix=CHECK-ASEXEC-OUT < %t.out %s
 # RUN: FileCheck --check-prefix=CHECK-ASEXEC-ERR < %t.err %s