[lit] Force site configs to be run before source-tree configs

This patch simplifies LLVM's lit infrastructure by enforcing an ordering
that a site config is always run before a source-tree config.

A significant amount of the complexity from lit config files arises from
the fact that inside of a source-tree config file, we don't yet know if
the site config has been run.  However it is *always* required to run
a site config first, because it passes various variables down through
CMake that the main config depends on.  As a result, every config
file has to do a bunch of magic to try to reverse-engineer the location
of the site config file if they detect (heuristically) that the site
config file has not yet been run.

This patch solves the problem by emitting a mapping from source tree
config file to binary tree site config file in llvm-lit.py. Then, during
discovery when we find a config file, we check to see if we have a
target mapping for it, and if so we use that instead.

This mechanism is generic enough that it does not affect external users
of lit. They will just not have a config mapping defined, and everything
will work as normal.

On the other hand, for us it allows us to make many simplifications:

* We are guaranteed that a site config will be executed first
* Inside of a main config, we no longer have to assume that attributes
  might not be present and use getattr everywhere.
* We no longer have to pass parameters such as --param llvm_site_config=<path>
  on the command line.
* It is future-proof, meaning you don't have to edit llvm-lit.in to add
  support for new projects.
* All of the duplicated logic of trying various fallback mechanisms of
  finding a site config from the main config are now gone.

One potentially noteworthy thing that was required to implement this
change is that whereas the ninja check targets previously used the first
method to spawn lit, they now use the second. In particular, you can no
longer run lit.py against the source tree while specifying the various
`foo_site_config=<path>` parameters.  Instead, you need to run
llvm-lit.py.

Differential Revision: https://reviews.llvm.org/D37756

llvm-svn: 313270

22 files changed, 183 insertions, 789 deletions

diff --git a/clang-tools-extra/test/Unit/lit.cfg b/clang-tools-extra/test/Unit/lit.cfg
index 3a1da187eb4..9388f804362 100644
--- a/clang-tools-extra/test/Unit/lit.cfg
+++ b/clang-tools-extra/test/Unit/lit.cfg
@@ -9,10 +9,9 @@ config.suffixes = [] # Seems not to matter for google tests?
 
 # Test Source and Exec root dirs both point to the same directory where google
 # test binaries are built.
-extra_tools_obj_dir = getattr(config, 'extra_tools_obj_dir', None)
-if extra_tools_obj_dir is not None:
-  config.test_source_root = extra_tools_obj_dir
-  config.test_exec_root = config.test_source_root
+
+config.test_source_root = config.extra_tools_obj_dir
+config.test_exec_root = config.test_source_root
 
 # All GoogleTests are named to have 'Tests' as their suffix. The '.' option is
 # a special value for GoogleTest indicating that it should look through the
@@ -20,18 +19,6 @@ if extra_tools_obj_dir is not None:
 # ;-separated list of subdirectories).
 config.test_format = lit.formats.GoogleTest('.', 'Tests')
 
-# If the site-specific configuration wasn't loaded (e.g. the build system failed
-# to create it or the user is running a test file directly) try to come up with
-# sane config options.
-if config.test_exec_root is None:
-  # Look for a --param=extra_tools_unit_site_config option.
-  site_cfg = lit_config.params.get('extra_tools_unit_site_config', None)
-  if site_cfg and os.path.exists(site_cfg):
-      lit_config.load_config(config, site_cfg)
-      raise SystemExit
-
-  # FIXME: Support out-of-tree builds? See clang/test/Unit/lit.cfg if we care.
-
 shlibpath_var = ''
 if platform.system() == 'Linux':
     shlibpath_var = 'LD_LIBRARY_PATH'
@@ -41,17 +28,11 @@ elif platform.system() == 'Windows':
     shlibpath_var = 'PATH'
 
 # Point the dynamic loader at dynamic libraries in 'lib'.
-shlibdir = getattr(config, 'shlibdir', None)
-if not shlibdir:
-    lit_config.fatal('No shlibdir set!')
-llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-if not llvm_libs_dir:
-    lit_config.fatal('No LLVM libs dir set!')
-shlibpath = os.path.pathsep.join((shlibdir, llvm_libs_dir,
+shlibpath = os.path.pathsep.join((config.shlibdir, config.llvm_libs_dir,
                                  config.environment.get(shlibpath_var,'')))
 
 # Win32 seeks DLLs along %PATH%.
 if sys.platform in ['win32', 'cygwin'] and os.path.isdir(shlibdir):
-    shlibpath = os.path.pathsep.join((shlibdir, shlibpath))
+    shlibpath = os.path.pathsep.join((config.shlibdir, shlibpath))
 
 config.environment[shlibpath_var] = shlibpath
diff --git a/clang-tools-extra/test/lit.cfg b/clang-tools-extra/test/lit.cfg
index 25f29189bc9..3bffbdbdf4d 100644
--- a/clang-tools-extra/test/lit.cfg
+++ b/clang-tools-extra/test/lit.cfg
@@ -54,9 +54,7 @@ config.excludes = ['Inputs']
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
-clang_tools_binary_dir = getattr(config, 'clang_tools_binary_dir', None)
-if clang_tools_binary_dir is not None:
-    config.test_exec_root = os.path.join(clang_tools_binary_dir, 'test')
+config.test_exec_root = os.path.join(config.clang_tools_binary_dir, 'test')
 
 # Clear some environment variables that might affect Clang.
 #
@@ -88,92 +86,19 @@ for name in possibly_dangerous_env_vars:
     del config.environment[name]
 
 # Tweak the PATH to include the tools dir and the scripts dir.
-if clang_tools_binary_dir is not None:
-    clang_tools_dir = getattr(config, 'clang_tools_dir', None)
-    if not clang_tools_dir:
-        lit_config.fatal('No Clang tools dir set!')
-    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-    if not llvm_tools_dir:
-        lit_config.fatal('No LLVM tools dir set!')
-    path = os.path.pathsep.join((
-            clang_tools_dir, llvm_tools_dir, config.environment['PATH']))
-    config.environment['PATH'] = path
-
-    clang_libs_dir = getattr(config, 'clang_libs_dir', None)
-    if not clang_libs_dir:
-        lit_config.fatal('No Clang libs dir set!')
-    llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-    if not llvm_libs_dir:
-        lit_config.fatal('No LLVM libs dir set!')
-    path = os.path.pathsep.join((clang_libs_dir, llvm_libs_dir,
-                                 config.environment.get('LD_LIBRARY_PATH','')))
-    config.environment['LD_LIBRARY_PATH'] = path
-
-###
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'clang_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('clang_tools_extra_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system though,
-    # and I decided it was too much magic. We should solve this by just having
-    # the .cfg files generated during the configuration step.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = lit.util.capture(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = lit.util.capture(['llvm-config', '--obj-root']).strip()
-    clang_src_root = os.path.join(llvm_src_root, "tools", "clang")
-    clang_obj_root = os.path.join(llvm_obj_root, "tools", "clang")
-
-    clang_tools_extra_src_root = os.path.join(clang_src_root, "tools", "extra")
-    clang_tools_extra_obj_root = os.path.join(clang_obj_root, "tools", "extra")
-    # Validate that we got a tree which points to here, using the standard
-    # tools/clang layout.
-    this_src_root = os.path.dirname(config.test_source_root)
-    if os.path.realpath(clang_tools_extra_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(clang_tools_extra_obj_root, 'test', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal(
-            'No site specific configuration available! You may need to '
-            'run "make test" in your Clang build directory.')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % clang_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
-
-###
+path = os.path.pathsep.join((
+        config.clang_tools_dir, config.llvm_tools_dir, config.environment['PATH']))
+config.environment['PATH'] = path
 
-import os
+path = os.path.pathsep.join((config.clang_libs_dir, config.llvm_libs_dir,
+                              config.environment.get('LD_LIBRARY_PATH','')))
+config.environment['LD_LIBRARY_PATH'] = path
 
 # When running under valgrind, we mangle '-vg' onto the end of the triple so we
 # can check it with XFAIL and XTARGET.
 if lit_config.useValgrind:
     config.target_triple += '-vg'
 
-###
-
 # Set available features we allow tests to conditionalize on.
 #
 # As of 2011.08, crash-recovery tests still do not pass on FreeBSD.
diff --git a/clang/test/Unit/lit.cfg b/clang/test/Unit/lit.cfg
index 90eb2ac604a..c4794ccbe58 100644
--- a/clang/test/Unit/lit.cfg
+++ b/clang/test/Unit/lit.cfg
@@ -17,14 +17,11 @@ config.suffixes = []
 
 # test_source_root: The root path where tests are located.
 # test_exec_root: The root path where tests should be run.
-clang_obj_root = getattr(config, 'clang_obj_root', None)
-if clang_obj_root is not None:
-    config.test_exec_root = os.path.join(clang_obj_root, 'unittests')
-    config.test_source_root = config.test_exec_root
+config.test_exec_root = os.path.join(config.clang_obj_root, 'unittests')
+config.test_source_root = config.test_exec_root
 
 # testFormat: The test format to use to interpret tests.
-llvm_build_mode = getattr(config, 'llvm_build_mode', "Debug")
-config.test_format = lit.formats.GoogleTest(llvm_build_mode, '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.
@@ -38,55 +35,6 @@ for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']:
     if symbolizer in os.environ:
         config.environment[symbolizer] = os.environ[symbolizer]
 
-###
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'clang_unit_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('clang_unit_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system
-    # though, and I decided it was too much magic.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = subprocess.check_output(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = subprocess.check_output(['llvm-config', '--obj-root']).strip()
-    clang_src_root = os.path.join(llvm_src_root, "tools", "clang")
-    clang_obj_root = os.path.join(llvm_obj_root, "tools", "clang")
-
-    # Validate that we got a tree which points to here, using the standard
-    # tools/clang layout.
-    this_src_root = os.path.join(os.path.dirname(__file__),'..','..')
-    if os.path.realpath(clang_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(clang_obj_root, 'test', 'Unit', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % clang_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
-
 shlibpath_var = ''
 if platform.system() == 'Linux':
     shlibpath_var = 'LD_LIBRARY_PATH'
@@ -97,14 +45,7 @@ elif platform.system() == 'Windows':
 
 # in stand-alone builds, shlibdir is clang's build tree
 # while llvm_libs_dir is installed LLVM (and possibly older clang)
-llvm_shlib_dir = getattr(config, 'shlibdir', None)
-if not llvm_shlib_dir:
-    lit_config.fatal('No shlibdir set!')
-# Point the dynamic loader at dynamic libraries in 'lib'.
-llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-if not llvm_libs_dir:
-    lit_config.fatal('No LLVM libs dir set!')
-shlibpath = os.path.pathsep.join((llvm_shlib_dir, llvm_libs_dir,
+shlibpath = os.path.pathsep.join((config.shlibdir, config.llvm_libs_dir,
                                  config.environment.get(shlibpath_var,'')))
 
 config.environment[shlibpath_var] = shlibpath
diff --git a/clang/test/lit.cfg b/clang/test/lit.cfg
index 6b7159ced8d..d258286274e 100644
--- a/clang/test/lit.cfg
+++ b/clang/test/lit.cfg
@@ -55,13 +55,7 @@ config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
-clang_obj_root = getattr(config, 'clang_obj_root', None)
-if clang_obj_root is not None:
-    config.test_exec_root = os.path.join(clang_obj_root, 'test')
-
-# Set llvm_{src,obj}_root for use by others.
-config.llvm_src_root = getattr(config, 'llvm_src_root', None)
-config.llvm_obj_root = getattr(config, 'llvm_obj_root', None)
+config.test_exec_root = os.path.join(config.clang_obj_root, 'test')
 
 # Clear some environment variables that might affect Clang.
 #
@@ -92,91 +86,20 @@ for name in possibly_dangerous_env_vars:
     del config.environment[name]
 
 # Tweak the PATH to include the tools dir and the scripts dir.
-if clang_obj_root is not None:
-    clang_tools_dir = getattr(config, 'clang_tools_dir', None)
-    if not clang_tools_dir:
-        lit_config.fatal('No Clang tools dir set!')
-    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-    if not llvm_tools_dir:
-        lit_config.fatal('No LLVM tools dir set!')
-    path = os.path.pathsep.join((
-            clang_tools_dir, llvm_tools_dir, config.environment['PATH']))
-    config.environment['PATH'] = path
-    # in stand-alone builds, llvm_shlib_dir is clang's build tree
-    # while llvm_libs_dir is installed LLVM (and possibly older clang)
-    llvm_shlib_dir = getattr(config, 'llvm_shlib_dir', None)
-    if not llvm_shlib_dir:
-        lit_config.fatal('No LLVM shlib dir set!')
-    llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-    if not llvm_libs_dir:
-        lit_config.fatal('No LLVM libs dir set!')
-    path = os.path.pathsep.join((llvm_shlib_dir, llvm_libs_dir,
-                                 config.environment.get('LD_LIBRARY_PATH','')))
-    config.environment['LD_LIBRARY_PATH'] = path
+path = os.path.pathsep.join((
+        config.clang_tools_dir, config.llvm_tools_dir, config.environment['PATH']))
+config.environment['PATH'] = path
+path = os.path.pathsep.join((config.llvm_shlib_dir, config.llvm_libs_dir,
+                              config.environment.get('LD_LIBRARY_PATH','')))
+config.environment['LD_LIBRARY_PATH'] = path
 
 # 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]
 
-###
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'clang_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('clang_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system though,
-    # and I decided it was too much magic. We should solve this by just having
-    # the .cfg files generated during the configuration step.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = subprocess.check_output(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = subprocess.check_output(['llvm-config', '--obj-root']).strip()
-    clang_src_root = os.path.join(llvm_src_root, "tools", "clang")
-    clang_obj_root = os.path.join(llvm_obj_root, "tools", "clang")
-
-    # Validate that we got a tree which points to here, using the standard
-    # tools/clang layout.
-    this_src_root = os.path.dirname(config.test_source_root)
-    if os.path.realpath(clang_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(clang_obj_root, 'test', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal(
-            'No site specific configuration available! You may need to '
-            'run "make test" in your Clang build directory.')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % clang_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
-
-###
-
 # Discover the 'clang' and 'clangcc' to use.
 
-import os
-
 def inferClang(PATH):
     # Determine which clang to use.
     clang = os.getenv('CLANG')
@@ -315,7 +238,7 @@ config.substitutions.append(
 # 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.
-tool_dirs = os.path.pathsep.join((clang_tools_dir, llvm_tools_dir))
+tool_dirs = os.path.pathsep.join((config.clang_tools_dir, config.llvm_tools_dir))
 
 # Regex assertions to reject neighbor hyphens/dots (seen in some tests).
 # For example, don't match 'clang-check-' or '.clang-format'.
@@ -351,7 +274,7 @@ for pattern in tool_patterns:
     if not tool_path:
         # Warn, but still provide a substitution.
         lit_config.note('Did not find ' + tool_name + ' in ' + tool_dirs)
-        tool_path = clang_tools_dir + '/' + tool_name
+        tool_path = config.clang_tools_dir + '/' + tool_name
     config.substitutions.append((pattern, tool_pipe + tool_path))
 
 ###
@@ -451,7 +374,7 @@ def get_llvm_config_props():
 
     cmd = subprocess.Popen(
         [
-            os.path.join(llvm_tools_dir, 'llvm-config'),
+            os.path.join(config.llvm_tools_dir, 'llvm-config'),
             '--assertion-mode',
             '--targets-built',
             '--cxxflags'
diff --git a/compiler-rt/test/lit.common.cfg b/compiler-rt/test/lit.common.cfg
index 4f23ab28550..6c07ca66195 100644
--- a/compiler-rt/test/lit.common.cfg
+++ b/compiler-rt/test/lit.common.cfg
@@ -73,10 +73,9 @@ for name in possibly_dangerous_env_vars:
     del config.environment[name]
 
 # Tweak PATH to include llvm tools dir.
-llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-if (not llvm_tools_dir) or (not os.path.exists(llvm_tools_dir)):
-  lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % llvm_tools_dir)
-path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
+if (not config.llvm_tools_dir) or (not os.path.exists(config.llvm_tools_dir)):
+  lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % config.llvm_tools_dir)
+path = os.path.pathsep.join((config.llvm_tools_dir, config.environment['PATH']))
 config.environment['PATH'] = path
 
 # Help MSVS link.exe find the standard libraries.
@@ -193,7 +192,7 @@ if config.host_os == 'Darwin':
 else:
   config.substitutions.append( ("%macos_min_target_10_11", "") )
 
-sancovcc_path = os.path.join(llvm_tools_dir, "sancov") 
+sancovcc_path = os.path.join(config.llvm_tools_dir, "sancov")
 if os.path.exists(sancovcc_path):
   config.available_features.add("has_sancovcc")
   config.substitutions.append( ("%sancovcc ", sancovcc_path) )
@@ -254,7 +253,7 @@ try:
       stdout = subprocess.PIPE,
       env=config.environment)
 except OSError:
-  print("Could not find llvm-config in " + llvm_tools_dir)
+  print("Could not find llvm-config in " + config.llvm_tools_dir)
   exit(42)
 
 if re.search(r'ON', llvm_config_cmd.stdout.read().decode('ascii')):
diff --git a/compiler-rt/test/profile/lit.cfg b/compiler-rt/test/profile/lit.cfg
index 9ca394212e9..7f0d95a9a39 100644
--- a/compiler-rt/test/profile/lit.cfg
+++ b/compiler-rt/test/profile/lit.cfg
@@ -22,17 +22,6 @@ if hasattr(config, 'profile_lit_binary_dir') and \
         config.profile_lit_binary_dir is not None:
     config.test_exec_root = os.path.join(config.profile_lit_binary_dir, config.name)
 
-# If the above check didn't work, we're probably in the source tree.  Use some
-# magic to re-execute from the build tree.
-if config.test_exec_root is None:
-    # The magic relies on knowing compilerrt_site_basedir.
-    compilerrt_basedir = lit_config.params.get('compilerrt_site_basedir', None)
-    if compilerrt_basedir:
-        site_cfg = os.path.join(compilerrt_basedir, 'profile', 'lit.site.cfg')
-        if os.path.exists(site_cfg):
-            lit_config.load_config(config, site_cfg)
-            raise SystemExit
-
 if config.host_os in ['Linux']:
   extra_link_flags = ["-ldl"]
 else:
diff --git a/compiler-rt/unittests/lit.common.unit.cfg b/compiler-rt/unittests/lit.common.unit.cfg
index b08c1fe1283..31206e913bf 100644
--- a/compiler-rt/unittests/lit.common.unit.cfg
+++ b/compiler-rt/unittests/lit.common.unit.cfg
@@ -16,7 +16,7 @@ config.test_format = lit.formats.GoogleTest(llvm_build_mode, "Test")
 config.suffixes = []
 
 # Tweak PATH to include llvm tools dir.
-llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
+llvm_tools_dir = config.llvm_tools_dir
 if (not llvm_tools_dir) or (not os.path.exists(llvm_tools_dir)):
   lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % llvm_tools_dir)
 path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
diff --git a/lld/test/Unit/lit.cfg b/lld/test/Unit/lit.cfg
index 4bc973a58ed..dac9f5dc6c3 100644
--- a/lld/test/Unit/lit.cfg
+++ b/lld/test/Unit/lit.cfg
@@ -17,7 +17,21 @@ config.suffixes =  []
 config.test_source_root = os.path.join(config.lld_obj_root, 'unittests')
 config.test_exec_root = config.test_source_root
 
+
+# Tweak the PATH to include the tools dir.
+path = os.path.pathsep.join((config.lld_tools_dir, config.llvm_tools_dir, config.environment['PATH']))
+config.environment['PATH'] = path
+
+path = os.path.pathsep.join((config.lld_libs_dir, config.llvm_libs_dir,
+                              config.environment.get('LD_LIBRARY_PATH','')))
+config.environment['LD_LIBRARY_PATH'] = path
+
+# Propagate LLVM_SRC_ROOT into the environment.
+config.environment['LLVM_SRC_ROOT'] = config.llvm_src_root
+
+# Propagate PYTHON_EXECUTABLE into the environment
+config.environment['PYTHON_EXECUTABLE'] = sys.executable
+
+
 # testFormat: The test format to use to interpret tests.
-if not hasattr(config, 'llvm_build_mode'):
-    lit_config.fatal("unable to find llvm_build_mode value on config")
 config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, 'Tests')
diff --git a/lld/test/Unit/lit.site.cfg.in b/lld/test/Unit/lit.site.cfg.in
index c2f3054a2d5..30e8933eb5f 100644
--- a/lld/test/Unit/lit.site.cfg.in
+++ b/lld/test/Unit/lit.site.cfg.in
@@ -8,6 +8,8 @@ config.llvm_build_mode = "@LLVM_BUILD_MODE@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.lld_obj_root = "@LLD_BINARY_DIR@"
 config.lld_src_root = "@LLD_SOURCE_DIR@"
+config.lld_libs_dir = "@LLVM_LIBRARY_OUTPUT_INTDIR@"
+config.lld_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 
diff --git a/lld/test/lit.cfg b/lld/test/lit.cfg
index 2a6cdd6341e..e27d0903d46 100644
--- a/lld/test/lit.cfg
+++ b/lld/test/lit.cfg
@@ -55,95 +55,23 @@ config.excludes = ['Inputs']
 # 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.
-lld_obj_root = getattr(config, 'lld_obj_root', None)
-if lld_obj_root is not None:
-    config.test_exec_root = os.path.join(lld_obj_root, 'test')
+config.test_exec_root = os.path.join(config.lld_obj_root, 'test')
 
-# Set llvm_{src,obj}_root for use by others.
-config.llvm_src_root = getattr(config, 'llvm_src_root', None)
-config.llvm_obj_root = getattr(config, 'llvm_obj_root', None)
 
 # Tweak the PATH to include the tools dir and the scripts dir.
-if lld_obj_root is not None:
-    lld_tools_dir = getattr(config, 'lld_tools_dir', None)
-    if not lld_tools_dir:
-        lit_config.fatal('No LLD tools dir set!')
-    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-    if not llvm_tools_dir:
-        lit_config.fatal('No LLVM tools dir set!')
-    path = os.path.pathsep.join((lld_tools_dir, llvm_tools_dir, config.environment['PATH']))
-    path = os.path.pathsep.join((os.path.join(getattr(config, 'llvm_src_root', None),'test','Scripts'),path))
-
-    config.environment['PATH'] = path
-
-    lld_libs_dir = getattr(config, 'lld_libs_dir', None)
-    if not lld_libs_dir:
-        lit_config.fatal('No LLD libs dir set!')
-    llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-    if not llvm_libs_dir:
-        lit_config.fatal('No LLVM libs dir set!')
-    path = os.path.pathsep.join((lld_libs_dir, llvm_libs_dir,
-                                 config.environment.get('LD_LIBRARY_PATH','')))
-    config.environment['LD_LIBRARY_PATH'] = path
-
-    # Propagate LLVM_SRC_ROOT into the environment.
-    config.environment['LLVM_SRC_ROOT'] = getattr(config, 'llvm_src_root', '')
-
-    # Propagate PYTHON_EXECUTABLE into the environment
-    config.environment['PYTHON_EXECUTABLE'] = getattr(config, 'python_executable',
-                                                      '')
-###
+path = os.path.pathsep.join((config.lld_tools_dir, config.llvm_tools_dir, config.environment['PATH']))
+
+config.environment['PATH'] = path
+
+path = os.path.pathsep.join((config.lld_libs_dir, config.llvm_libs_dir,
+                              config.environment.get('LD_LIBRARY_PATH','')))
+config.environment['LD_LIBRARY_PATH'] = path
+
+# Propagate LLVM_SRC_ROOT into the environment.
+config.environment['LLVM_SRC_ROOT'] = config.llvm_src_root
 
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'lld_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('lld_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system though,
-    # and I decided it was too much magic. We should solve this by just having
-    # the .cfg files generated during the configuration step.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = subprocess.check_output(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = subprocess.check_output(['llvm-config', '--obj-root']).strip()
-    lld_src_root = os.path.join(llvm_src_root, "tools", "lld")
-    lld_obj_root = os.path.join(llvm_obj_root, "tools", "lld")
-
-    # Validate that we got a tree which points to here, using the standard
-    # tools/lld layout.
-    this_src_root = os.path.dirname(config.test_source_root)
-    if os.path.realpath(lld_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(lld_obj_root, 'test', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal(
-            'No site specific configuration available! You may need to '
-            'run "make test" in your lld build directory.')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % lld_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
+# Propagate PYTHON_EXECUTABLE into the environment
+config.environment['PYTHON_EXECUTABLE'] = sys.executable
 
 # For each occurrence of a lld tool name as its own word, replace it
 # with the full path to the build directory holding that tool.  This
@@ -185,7 +113,7 @@ for pattern in tool_patterns:
     if not tool_path:
         # Warn, but still provide a substitution.
         lit_config.note('Did not find ' + tool_name + ' in ' + path)
-        tool_path = llvm_tools_dir + '/' + tool_name
+        tool_path = config.llvm_tools_dir + '/' + tool_name
     config.substitutions.append((pattern, tool_pipe + tool_path))
 
 # Add site-specific substitutions.
@@ -227,11 +155,11 @@ if platform.system() not in ['Windows']:
 import subprocess
 try:
     llvm_config_cmd = \
-     subprocess.Popen([os.path.join(llvm_tools_dir, 'llvm-config'),
+     subprocess.Popen([os.path.join(config.llvm_tools_dir, 'llvm-config'),
                      '--build-mode', '--assertion-mode', '--targets-built'],
                       stdout = subprocess.PIPE)
 except OSError as why:
-    print("Could not find llvm-config in " + llvm_tools_dir)
+    print("Could not find llvm-config in " + config.llvm_tools_dir)
     exit(42)
 
 llvm_config_output = llvm_config_cmd.stdout.read().decode('utf_8')
diff --git a/lldb/lit/Unit/lit.cfg b/lldb/lit/Unit/lit.cfg
index 7dfb344e6fa..338adfd7bd9 100644
--- a/lldb/lit/Unit/lit.cfg
+++ b/lldb/lit/Unit/lit.cfg
@@ -6,19 +6,6 @@ import os
 
 import lit.formats
 
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'llvm_unit_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('lldb_unit_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
 # name: The name of this test suite.
 config.name = 'lldb-Unit'
 
@@ -31,6 +18,4 @@ config.test_source_root = os.path.join(config.lldb_obj_root, 'unittests')
 config.test_exec_root = config.test_source_root
 
 # testFormat: The test format to use to interpret tests.
-if not hasattr(config, 'llvm_build_mode'):
-    lit_config.fatal("unable to find llvm_build_mode value on config")
 config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, 'Tests')
diff --git a/lldb/lit/lit.cfg b/lldb/lit/lit.cfg
index 8dea61b2716..1e083fd14d2 100644
--- a/lldb/lit/lit.cfg
+++ b/lldb/lit/lit.cfg
@@ -29,94 +29,24 @@ config.suffixes = []
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
-lldb_obj_root = getattr(config, 'lldb_obj_root', None)
-if lldb_obj_root is not None:
-    config.test_exec_root = os.path.join(lldb_obj_root, 'lit')
-
-# Set llvm_{src,obj}_root for use by others.
-config.llvm_src_root = getattr(config, 'llvm_src_root', None)
-config.llvm_obj_root = getattr(config, 'llvm_obj_root', None)
+config.test_exec_root = os.path.join(config.lldb_obj_root, 'lit')
 
 # Tweak the PATH to include the tools dir and the scripts dir.
-if lldb_obj_root is not None:
-    lldb_tools_dir = getattr(config, 'lldb_tools_dir', None)
-    if not lldb_tools_dir:
-        lit_config.fatal('No LLDB tools dir set!')
-    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-    if not llvm_tools_dir:
-        lit_config.fatal('No LLVM tools dir set!')
-    path = os.path.pathsep.join((lldb_tools_dir, llvm_tools_dir, config.environment['PATH']))
-    path = os.path.pathsep.join((os.path.join(getattr(config, 'llvm_src_root', None),'test','Scripts'),path))
-
-    config.environment['PATH'] = path
-
-    lldb_libs_dir = getattr(config, 'lldb_libs_dir', None)
-    if not lldb_libs_dir:
-        lit_config.fatal('No LLDB libs dir set!')
-    llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-    if not llvm_libs_dir:
-        lit_config.fatal('No LLVM libs dir set!')
-    path = os.path.pathsep.join((lldb_libs_dir, llvm_libs_dir,
-                                 config.environment.get('LD_LIBRARY_PATH','')))
-    config.environment['LD_LIBRARY_PATH'] = path
-
-    # Propagate LLVM_SRC_ROOT into the environment.
-    config.environment['LLVM_SRC_ROOT'] = getattr(config, 'llvm_src_root', '')
-
-    # Propagate PYTHON_EXECUTABLE into the environment
-    config.environment['PYTHON_EXECUTABLE'] = getattr(config, 'python_executable',
-                                                      '')
-###
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'lldb_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('lldb_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system though,
-    # and I decided it was too much magic. We should solve this by just having
-    # the .cfg files generated during the configuration step.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = subprocess.check_output(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = subprocess.check_output(['llvm-config', '--obj-root']).strip()
-    lldb_src_root = os.path.join(llvm_src_root, "tools", "lldb")
-    lldb_obj_root = os.path.join(llvm_obj_root, "tools", "lldb")
-
-    # Validate that we got a tree which points to here, using the standard
-    # tools/lldb layout.
-    this_src_root = os.path.dirname(config.test_source_root)
-    if os.path.realpath(lldb_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(lldb_obj_root, 'test', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal(
-            'No site specific configuration available! You may need to '
-            'run "make test" in your lldb build directory.')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % lldb_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
+lldb_tools_dir = config.lldb_tools_dir
+llvm_tools_dir = config.llvm_tools_dir
+path = os.path.pathsep.join((config.lldb_tools_dir, config.llvm_tools_dir, config.environment['PATH']))
+
+config.environment['PATH'] = path
+
+path = os.path.pathsep.join((config.lldb_libs_dir, config.llvm_libs_dir,
+                              config.environment.get('LD_LIBRARY_PATH','')))
+config.environment['LD_LIBRARY_PATH'] = path
+
+# Propagate LLVM_SRC_ROOT into the environment.
+config.environment['LLVM_SRC_ROOT'] = getattr(config, 'llvm_src_root', '')
+
+# Propagate PYTHON_EXECUTABLE into the environment
+config.environment['PYTHON_EXECUTABLE'] = getattr(config, 'python_executable',
 
 # Register substitutions
 config.substitutions.append(('%python', config.python_executable))
diff --git a/llvm/CMakeLists.txt b/llvm/CMakeLists.txt
index d08fd67ddaf..76d66b99fc8 100644
--- a/llvm/CMakeLists.txt
+++ b/llvm/CMakeLists.txt
@@ -845,7 +845,6 @@ if( LLVM_INCLUDE_UTILS )
   add_subdirectory(utils/PerfectShuffle)
   add_subdirectory(utils/count)
   add_subdirectory(utils/not)
-  add_subdirectory(utils/llvm-lit)
   add_subdirectory(utils/yaml-bench)
 else()
   if ( LLVM_INCLUDE_TESTS )
@@ -932,6 +931,11 @@ endif()
 
 add_subdirectory(cmake/modules)
 
+# Do this last so that all lit targets have already been created.
+if (LLVM_INCLUDE_UTILS)
+  add_subdirectory(utils/llvm-lit)
+endif()
+
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(DIRECTORY include/llvm include/llvm-c
     DESTINATION include
diff --git a/llvm/cmake/modules/AddLLVM.cmake b/llvm/cmake/modules/AddLLVM.cmake
index 66abb2486d9..b30d002aa20 100644
--- a/llvm/cmake/modules/AddLLVM.cmake
+++ b/llvm/cmake/modules/AddLLVM.cmake
@@ -1174,6 +1174,13 @@ function(configure_lit_site_cfg input output)
   endif()
 
   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}')")
+    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()
 
 # A raw function to create a lit target. This is used to implement the testuite
@@ -1185,12 +1192,16 @@ function(add_lit_target target comment)
   if (NOT CMAKE_CFG_INTDIR STREQUAL ".")
     list(APPEND LIT_ARGS --param build_mode=${CMAKE_CFG_INTDIR})
   endif ()
-  if (EXISTS ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
-    set (LIT_COMMAND "${PYTHON_EXECUTABLE};${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py"
-         CACHE STRING "Command used to spawn llvm-lit")
-  else()
-    find_program(LIT_COMMAND NAMES llvm-lit lit.py lit)
+
+  if (WIN32 AND NOT CYGWIN)
+    # llvm-lit needs suffix.py for multiprocess to find a main module.
+    set(suffix .py)
   endif ()
+  set(llvm_lit_path ${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-lit${suffix})
+
+  set (LIT_COMMAND "${PYTHON_EXECUTABLE};${llvm_lit_path}"
+        CACHE STRING "Command used to spawn llvm-lit" FORCE)
+
   list(APPEND LIT_COMMAND ${LIT_ARGS})
   foreach(param ${ARG_PARAMS})
     list(APPEND LIT_COMMAND --param ${param})
diff --git a/llvm/test/Unit/lit.cfg b/llvm/test/Unit/lit.cfg
index 9da82f5f2c9..609408d1dd8 100644
--- a/llvm/test/Unit/lit.cfg
+++ b/llvm/test/Unit/lit.cfg
@@ -18,14 +18,11 @@ 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.
-llvm_obj_root = getattr(config, 'llvm_obj_root', None)
-if llvm_obj_root is not None:
-    config.test_exec_root = os.path.join(llvm_obj_root, 'unittests')
-    config.test_source_root = config.test_exec_root
+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.
-llvm_build_mode = getattr(config, 'llvm_build_mode', "Debug")
-config.test_format = lit.formats.GoogleTest(llvm_build_mode, '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.
@@ -47,49 +44,3 @@ if sys.platform in ['win32', 'cygwin'] and os.path.isdir(config.shlibdir):
 # 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']
-
-###
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'llvm_unit_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('llvm_unit_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system
-    # though, and I decided it was too much magic.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = subprocess.check_output(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = subprocess.check_output(['llvm-config', '--obj-root']).strip()
-
-    # Validate that we got a tree which points to here.
-    this_src_root = os.path.join(os.path.dirname(__file__),'..','..')
-    if os.path.realpath(llvm_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(llvm_obj_root, 'test', 'Unit', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % llvm_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
diff --git a/llvm/test/lit.cfg b/llvm/test/lit.cfg
index 7d298f64a5f..05176dc6711 100644
--- a/llvm/test/lit.cfg
+++ b/llvm/test/lit.cfg
@@ -53,17 +53,11 @@ config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
-llvm_obj_root = getattr(config, 'llvm_obj_root', None)
-if llvm_obj_root is not None:
-    config.test_exec_root = os.path.join(llvm_obj_root, 'test')
+config.test_exec_root = os.path.join(config.llvm_obj_root, 'test')
 
 # Tweak the PATH to include the tools dir.
-if llvm_obj_root is not None:
-    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-    if not llvm_tools_dir:
-        lit_config.fatal('No LLVM tools dir set!')
-    path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
-    config.environment['PATH'] = path
+path = os.path.pathsep.join((config.llvm_tools_dir, config.environment['PATH']))
+config.environment['PATH'] = path
 
 # Propagate 'HOME' through the environment.
 if 'HOME' in os.environ:
@@ -85,7 +79,7 @@ if 'TEMP' in os.environ:
     config.environment['TEMP'] = os.environ['TEMP']
 
 # Propagate LLVM_SRC_ROOT into the environment.
-config.environment['LLVM_SRC_ROOT'] = getattr(config, 'llvm_src_root', '')
+config.environment['LLVM_SRC_ROOT'] = config.llvm_src_root
 
 # Propagate PYTHON_EXECUTABLE into the environment
 config.environment['PYTHON_EXECUTABLE'] = getattr(config, 'python_executable',
@@ -97,80 +91,23 @@ for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']:
         config.environment[symbolizer] = os.environ[symbolizer]
 
 # Set up OCAMLPATH to include newly built OCaml libraries.
-llvm_lib_dir = getattr(config, 'llvm_lib_dir', None)
-if llvm_lib_dir is None:
-    if llvm_obj_root is not None:
-        llvm_lib_dir = os.path.join(llvm_obj_root, 'lib')
-
-if llvm_lib_dir is not None:
-    top_ocaml_lib = os.path.join(llvm_lib_dir, 'ocaml')
-    llvm_ocaml_lib = os.path.join(top_ocaml_lib, 'llvm')
-    if llvm_ocaml_lib is not None:
-        ocamlpath = os.path.pathsep.join((llvm_ocaml_lib, top_ocaml_lib))
-        if 'OCAMLPATH' in os.environ:
-            ocamlpath = os.path.pathsep.join((ocamlpath, os.environ['OCAMLPATH']))
-        config.environment['OCAMLPATH'] = ocamlpath
-
-        if 'CAML_LD_LIBRARY_PATH' in os.environ:
-            caml_ld_library_path = os.path.pathsep.join((llvm_ocaml_lib,
-                                        os.environ['CAML_LD_LIBRARY_PATH']))
-            config.environment['CAML_LD_LIBRARY_PATH'] = caml_ld_library_path
-        else:
-            config.environment['CAML_LD_LIBRARY_PATH'] = llvm_ocaml_lib
+top_ocaml_lib = os.path.join(config.llvm_lib_dir, 'ocaml')
+llvm_ocaml_lib = os.path.join(top_ocaml_lib, 'llvm')
+ocamlpath = os.path.pathsep.join((llvm_ocaml_lib, top_ocaml_lib))
+if 'OCAMLPATH' in os.environ:
+    ocamlpath = os.path.pathsep.join((ocamlpath, os.environ['OCAMLPATH']))
+config.environment['OCAMLPATH'] = ocamlpath
+
+if 'CAML_LD_LIBRARY_PATH' in os.environ:
+    caml_ld_library_path = os.path.pathsep.join((llvm_ocaml_lib,
+                                os.environ['CAML_LD_LIBRARY_PATH']))
+    config.environment['CAML_LD_LIBRARY_PATH'] = caml_ld_library_path
+else:
+    config.environment['CAML_LD_LIBRARY_PATH'] = llvm_ocaml_lib
 
 # Set up OCAMLRUNPARAM to enable backtraces in OCaml tests.
 config.environment['OCAMLRUNPARAM'] = 'b'
 
-###
-
-import os
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'llvm_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('llvm_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system
-    # though, and I decided it was too much magic.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = subprocess.check_output(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = subprocess.check_output(['llvm-config', '--obj-root']).strip()
-
-    # Validate that we got a tree which points to here.
-    this_src_root = os.path.dirname(config.test_source_root)
-    if os.path.realpath(llvm_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(llvm_obj_root, 'test', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % llvm_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
-
-###
-
 # 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():
@@ -231,11 +168,11 @@ config.substitutions.append( ('%ld64', ld64_cmd) )
 # Support tests for both native and bytecode builds.
 config.substitutions.append( ('%ocamlc',
     "%s ocamlc -cclib -L%s %s" %
-        (config.ocamlfind_executable, llvm_lib_dir, config.ocaml_flags)) )
+        (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, llvm_lib_dir, llvm_lib_dir, config.ocaml_flags)) )
+            (config.ocamlfind_executable, config.llvm_lib_dir, config.llvm_lib_dir, config.ocaml_flags)) )
 else:
     config.substitutions.append( ('%ocamlopt', "true" ) )
 
@@ -267,7 +204,7 @@ def find_tool_substitution(pattern):
     # 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, llvm_tools_dir)
+        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
@@ -333,8 +270,8 @@ for pattern in [r"\bbugpoint\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 ' + llvm_tools_dir)
-        tool_path = llvm_tools_dir + '/' + tool_name
+        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
@@ -350,7 +287,7 @@ for pattern in [r"\bllvm-go\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 = llvm_tools_dir + '/' + tool_name
+        tool_path = config.llvm_tools_dir + '/' + tool_name
     config.substitutions.append((pattern, tool_pipe + tool_path))
 
 
@@ -482,11 +419,11 @@ if have_ld64_plugin_support():
 # Ask llvm-config about assertion mode.
 try:
     llvm_config_cmd = subprocess.Popen(
-        [os.path.join(llvm_tools_dir, 'llvm-config'), '--assertion-mode'],
+        [os.path.join(config.llvm_tools_dir, 'llvm-config'), '--assertion-mode'],
         stdout = subprocess.PIPE,
         env=config.environment)
 except OSError:
-    print("Could not find llvm-config in " + llvm_tools_dir)
+    print("Could not find llvm-config in " + config.llvm_tools_dir)
     exit(42)
 
 if re.search(r'ON', llvm_config_cmd.stdout.read().decode('ascii')):
@@ -538,11 +475,11 @@ if use_gmalloc:
 # Ask llvm-config about global-isel.
 try:
     llvm_config_cmd = subprocess.Popen(
-        [os.path.join(llvm_tools_dir, 'llvm-config'), '--has-global-isel'],
+        [os.path.join(config.llvm_tools_dir, 'llvm-config'), '--has-global-isel'],
         stdout = subprocess.PIPE,
         env=config.environment)
 except OSError:
-    print("Could not find llvm-config in " + llvm_tools_dir)
+    print("Could not find llvm-config in " + config.llvm_tools_dir)
     exit(42)
 
 if re.search(r'ON', llvm_config_cmd.stdout.read().decode('ascii')):
diff --git a/llvm/utils/lit/lit/discovery.py b/llvm/utils/lit/lit/discovery.py
index 8876dcba8f2..82dbfef7826 100644
--- a/llvm/utils/lit/lit/discovery.py
+++ b/llvm/utils/lit/lit/discovery.py
@@ -40,6 +40,20 @@ def getTestSuite(item, litConfig, cache):
             ts, relative = search(parent)
             return (ts, relative + (base,))
 
+        # This is a private builtin parameter which can be used to perform

+        # translation of configuration paths.  Specifically, this parameter
+        # can be set to a dictionary that the discovery process will consult
+        # when it finds a configuration it is about to load.  If the given
+        # path is in the map, the value of that key is a path to the

+        # configuration to load instead.
+        config_map = litConfig.params.get('config_map')
+        if config_map:
+            cfgpath = os.path.normpath(cfgpath)
+            cfgpath = os.path.normcase(cfgpath)
+            target = config_map.get(cfgpath)
+            if target:
+                cfgpath = target
+
         # We found a test suite, create a new config for it and load it.
         if litConfig.debug:
             litConfig.note('loading suite config %r' % cfgpath)
@@ -212,7 +226,7 @@ def find_tests_for_inputs(lit_config, inputs):
                 f.close()
         else:
             actual_inputs.append(input)
-                    
+
     # Load the tests from the inputs.
     tests = []
     test_suite_cache = {}
diff --git a/llvm/utils/lit/tests/lit.cfg b/llvm/utils/lit/tests/lit.cfg
index 0c98299285a..f2ecaa6d417 100644
--- a/llvm/utils/lit/tests/lit.cfg
+++ b/llvm/utils/lit/tests/lit.cfg
@@ -65,7 +65,6 @@ if sys.platform.startswith('win') or sys.platform.startswith('cygwin'):
     config.available_features.add('windows')
 
 # Add llvm tools directory if this config is being loaded indirectly
-llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-if llvm_tools_dir != None:
-    path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
+if config.llvm_tools_dir is not None:
+    path = os.path.pathsep.join((config.llvm_tools_dir, config.environment['PATH']))
     config.environment['PATH'] = path
diff --git a/llvm/utils/llvm-lit/CMakeLists.txt b/llvm/utils/llvm-lit/CMakeLists.txt
index 4b10354cfde..606d36ccf69 100644
--- a/llvm/utils/llvm-lit/CMakeLists.txt
+++ b/llvm/utils/llvm-lit/CMakeLists.txt
@@ -4,6 +4,8 @@ if (WIN32 AND NOT CYGWIN)
 endif ()
 set(llvm_lit_path ${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-lit${suffix})
 
+get_property(LLVM_LIT_CONFIG_MAP GLOBAL PROPERTY LLVM_LIT_CONFIG_MAP)
+
 if(NOT "${CMAKE_CFG_INTDIR}" STREQUAL ".")
   foreach(BUILD_MODE ${CMAKE_CONFIGURATION_TYPES})
     string(REPLACE ${CMAKE_CFG_INTDIR} ${BUILD_MODE} bi ${llvm_lit_path})
diff --git a/llvm/utils/llvm-lit/llvm-lit.in b/llvm/utils/llvm-lit/llvm-lit.in
index 08a2a670b21..efad97ade7e 100755
--- a/llvm/utils/llvm-lit/llvm-lit.in
+++ b/llvm/utils/llvm-lit/llvm-lit.in
@@ -3,6 +3,15 @@
 import os
 import sys
 
+config_map = {}
+
+def map_config(source_dir, site_config):
+    global config_map
+    source_dir = os.path.normpath(source_dir)
+    source_dir = os.path.normcase(source_dir)
+    site_config = os.path.normpath(site_config)
+    config_map[source_dir] = site_config
+
 # Variables configured at build time.
 llvm_source_root = "@LLVM_SOURCE_DIR@"
 llvm_obj_root = "@LLVM_BINARY_DIR@"
@@ -12,42 +21,11 @@ sys.path.insert(0, os.path.join(llvm_source_root, 'utils', 'lit'))
 
 # Set up some builtin parameters, so that by default the LLVM test suite
 # configuration file knows how to find the object tree.
-builtin_parameters = {
-    'build_mode' : "@BUILD_MODE@",
-    'llvm_site_config' : os.path.join(llvm_obj_root, 'test', 'lit.site.cfg'),
-    'llvm_unit_site_config' : os.path.join(llvm_obj_root, 'test', 'Unit',
-                                           'lit.site.cfg')
-    }
-
-clang_obj_root = os.path.join(llvm_obj_root, 'tools', 'clang')
-
-if os.path.exists(clang_obj_root):
-    builtin_parameters['clang_site_config'] = \
-        os.path.join(clang_obj_root, 'test', 'lit.site.cfg')
-    clang_tools_extra_obj_root = os.path.join(clang_obj_root, 'tools', 'extra')
-    if os.path.exists(clang_tools_extra_obj_root):
-        builtin_parameters['clang_tools_extra_site_config'] = \
-            os.path.join(clang_tools_extra_obj_root, 'test', 'lit.site.cfg')
-
-lld_obj_root = os.path.join(llvm_obj_root, 'tools', 'lld')
-if os.path.exists(lld_obj_root):
-    builtin_parameters['lld_site_config'] = \
-        os.path.join(lld_obj_root, 'test', 'lit.site.cfg')
-
-compilerrt_obj_root = os.path.join(llvm_obj_root, 'projects', 'compiler-rt')
-if os.path.exists(compilerrt_obj_root):
-    builtin_parameters['compilerrt_site_basedir'] = \
-            os.path.join(compilerrt_obj_root, 'test')
-
-libcxx_obj_root = os.path.join(llvm_obj_root, 'projects', 'libcxx')
-if os.path.exists(libcxx_obj_root):
-    builtin_parameters['libcxx_site_config'] = \
-        os.path.join(libcxx_obj_root, 'test', 'lit.site.cfg')
-
-libcxxabi_obj_root = os.path.join(llvm_obj_root, 'projects', 'libcxxabi')
-if os.path.exists(libcxxabi_obj_root):
-    builtin_parameters['libcxxabi_site_config'] = \
-        os.path.join(libcxxabi_obj_root, 'test', 'lit.site.cfg')
+builtin_parameters = { 'build_mode' : "@BUILD_MODE@" }
+
+@LLVM_LIT_CONFIG_MAP@
+
+builtin_parameters['config_map'] = config_map
 
 if __name__=='__main__':
     from lit.main import main
diff --git a/polly/test/Unit/lit.cfg b/polly/test/Unit/lit.cfg
index 9ac67f3acf4..315b70e7581 100644
--- a/polly/test/Unit/lit.cfg
+++ b/polly/test/Unit/lit.cfg
@@ -19,14 +19,11 @@ config.suffixes = []
 
 # test_source_root: The root path where tests are located.
 # test_exec_root: The root path where tests should be run.
-polly_obj_root = getattr(config, 'polly_obj_root', None)
-if polly_obj_root is not None:
-    config.test_exec_root = os.path.join(polly_obj_root, 'unittests')
-    config.test_source_root = config.test_exec_root
+config.test_exec_root = os.path.join(config.polly_obj_root, 'unittests')
+config.test_source_root = config.test_exec_root
 
 # testFormat: The test format to use to interpret tests.
-llvm_build_mode = getattr(config, 'llvm_build_mode', "Debug")
-config.test_format = lit.formats.GoogleTest(llvm_build_mode, '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.
@@ -40,55 +37,6 @@ for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']:
     if symbolizer in os.environ:
         config.environment[symbolizer] = os.environ[symbolizer]
 
-###
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'polly_unit_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('polly_unit_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system
-    # though, and I decided it was too much magic.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = lit.util.capture(['llvm-config', '--src-root']).strip()
-    llvm_obj_root = lit.util.capture(['llvm-config', '--obj-root']).strip()
-    polly_src_root = os.path.join(llvm_src_root, "tools", "polly")
-    polly_obj_root = os.path.join(llvm_obj_root, "tools", "polly")
-
-    # Validate that we got a tree which points to here, using the standard
-    # tools/clang layout.
-    this_src_root = os.path.join(os.path.dirname(__file__),'..','..')
-    if os.path.realpath(polly_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(polly_obj_root, 'test', 'Unit', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % polly_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
-
 shlibpath_var = ''
 if platform.system() == 'Linux':
     shlibpath_var = 'LD_LIBRARY_PATH'
@@ -98,10 +46,7 @@ elif platform.system() == 'Windows':
     shlibpath_var = 'PATH'
 
 # Point the dynamic loader at dynamic libraries in 'lib'.
-llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-if not llvm_libs_dir:
-    lit_config.fatal('No LLVM libs dir set!')
-shlibpath = os.path.pathsep.join((llvm_libs_dir,
+shlibpath = os.path.pathsep.join((config.llvm_libs_dir,
                                  config.environment.get(shlibpath_var,'')))
 
 # Win32 seeks DLLs along %PATH%.
diff --git a/polly/test/lit.cfg b/polly/test/lit.cfg
index ac4eeee52a7..293b4267392 100644
--- a/polly/test/lit.cfg
+++ b/polly/test/lit.cfg
@@ -27,90 +27,25 @@ config.suffixes = ['.ll']
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
-polly_obj_root = getattr(config, 'polly_obj_root', None)
-if polly_obj_root is not None:
-    config.test_exec_root = os.path.join(polly_obj_root, 'test')
-
-# Set llvm_{src,obj}_root for use by others.
-config.llvm_src_root = getattr(config, 'llvm_src_root', None)
-config.llvm_obj_root = getattr(config, 'llvm_obj_root', None)
+config.test_exec_root = os.path.join(config.polly_obj_root, 'test')
 
 # Tweak the PATH to include the tools dir and the scripts dir.
-if polly_obj_root is not None:
-    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
-    if not llvm_tools_dir:
-        lit_config.fatal('No LLVM tools dir set!')
-    extra_paths = getattr(config, 'extra_paths', [])
-    base_paths = [llvm_tools_dir, config.environment['PATH']]
-    path = os.path.pathsep.join(base_paths + extra_paths)
-    config.environment['PATH'] = path
-
-    llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
-    if not llvm_libs_dir:
-        lit_config.fatal('No LLVM libs dir set!')
-    path = os.path.pathsep.join((llvm_libs_dir,
-                                 config.environment.get('LD_LIBRARY_PATH','')))
-    config.environment['LD_LIBRARY_PATH'] = path
-
-###
-
-# Check that the object root is known.
-if config.test_exec_root is None:
-    # Otherwise, we haven't loaded the site specific configuration (the user is
-    # probably trying to run on a test file directly, and either the site
-    # configuration hasn't been created by the build system, or we are in an
-    # out-of-tree build situation).
-
-    # Check for 'polly_site_config' user parameter, and use that if available.
-    site_cfg = lit_config.params.get('polly_site_config', None)
-    if site_cfg and os.path.exists(site_cfg):
-        lit_config.load_config(config, site_cfg)
-        raise SystemExit
-
-    # Try to detect the situation where we are using an out-of-tree build by
-    # looking for 'llvm-config'.
-    #
-    # FIXME: I debated (i.e., wrote and threw away) adding logic to
-    # automagically generate the lit.site.cfg if we are in some kind of fresh
-    # build situation. This means knowing how to invoke the build system though,
-    # and I decided it was too much magic. We should solve this by just having
-    # the .cfg files generated during the configuration step.
-
-    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
-    if not llvm_config:
-        lit_config.fatal('No site specific configuration available!')
-
-    # Get the source and object roots.
-    llvm_src_root = subprocess.check_output(['llvm-config', '--src-root']).decode("utf-8").strip()
-    llvm_obj_root = subprocess.check_output(['llvm-config', '--obj-root']).decode("utf-8").strip()
-
-    polly_src_root = os.path.join(llvm_src_root, "tools", "polly")
-    polly_obj_root = os.path.join(llvm_obj_root, "tools", "polly")
-
-    # Validate that we got a tree which points to here, using the standard
-    # tools/polly layout.
-    this_src_root = os.path.dirname(config.test_source_root)
-    if os.path.realpath(polly_src_root) != os.path.realpath(this_src_root):
-        lit_config.fatal('No site specific configuration available!')
-
-    # Check that the site specific configuration exists.
-    site_cfg = os.path.join(polly_obj_root, 'test', 'lit.site.cfg')
-    if not os.path.exists(site_cfg):
-        lit_config.fatal('No site specific configuration available!')
+base_paths = [config.llvm_tools_dir, config.environment['PATH']]
+path = os.path.pathsep.join(base_paths + config.extra_paths)
+config.environment['PATH'] = path
 
-    # Okay, that worked. Notify the user of the automagic, and reconfigure.
-    lit_config.note('using out-of-tree build at %r' % polly_obj_root)
-    lit_config.load_config(config, site_cfg)
-    raise SystemExit
+path = os.path.pathsep.join((config.llvm_libs_dir,
+                              config.environment.get('LD_LIBRARY_PATH','')))
+config.environment['LD_LIBRARY_PATH'] = path
 
 # opt knows whether it is compiled with -DNDEBUG.
 import subprocess
 try:
-    opt_cmd = subprocess.Popen([os.path.join(llvm_tools_dir, 'opt'), '-version'],
+    opt_cmd = subprocess.Popen([os.path.join(config.llvm_tools_dir, 'opt'), '-version'],
                            stdout = subprocess.PIPE,
                            env=config.environment)
 except OSError:
-    print("Could not find opt in " + llvm_tools_dir)
+    print("Could not find opt in " + config.llvm_tools_dir)
     exit(42)
 
 if re.search(r'with assertions', opt_cmd.stdout.read().decode('ascii')):
@@ -118,13 +53,14 @@ if re.search(r'with assertions', opt_cmd.stdout.read().decode('ascii')):
 opt_cmd.wait()
 
 try:
-    llvm_config_cmd = subprocess.Popen([os.path.join(llvm_tools_dir,
-                                                     'llvm-config'),
+    llvm_config_cmd = subprocess.Popen([os.path.join(
+                                        config.llvm_tools_dir,
+                                        'llvm-config'),
                                         '--targets-built'],
                                        stdout = subprocess.PIPE,
                                        env=config.environment)
 except OSError:
-    print("Could not find llvm-config in " + llvm_tools_dir)
+    print("Could not find llvm-config in " + config.llvm_tools_dir)
     exit(42)
 
 if re.search(r'NVPTX', llvm_config_cmd.stdout.read().decode('ascii')):