[test] lit.cfg: Introduce config.target_library_path_var for the correct spelling of DYLD_LIBRARY_PATH

Instead of setting a random subset of `DYLD_LIBRARY_PATH`, `LD_LIBRARY_PATH`, `SIMCTL_CHILD_DYLD_LIBRARY_PATH`, `REMOTE_RUN_CHILD_DYLD_LIBRARY_PATH`, and `REMOTE_RUN_CHILD_LD_LIBRARY_PATH` in each `target_run` configuration, simply arrange for the single correct variable name to be in `config.target_library_path_var`, and set it only once.

This should remove irrelevant environment variables from test logs, making them a little less confusing.

Author: lorentey

test/lit.cfg

@@ -955,6 +955,7 @@ if run_vendor == 'apple':
         config.target_codesign = make_path(config.swift_utils, "swift-darwin-postprocess.py")
     else:
         config.target_codesign = "codesign -f -s -"
+    config.target_library_path_var = "DYLD_LIBRARY_PATH"
     config.target_runtime = "objc"
 
     config.available_features.add('libdispatch')
@@ -1453,6 +1454,7 @@ elif (run_os in ['linux-gnu', 'linux-gnueabihf', 'freebsd', 'openbsd', 'windows-
       config.target_shared_library_suffix = ".so"
       config.target_sdk_name = "linux"
       config.target_cc_options = "-fPIE"
+    config.target_library_path_var = "LD_LIBRARY_PATH"
     config.target_runtime = "native"
     config.target_swift_autolink_extract = inferSwiftBinary("swift-autolink-extract")
 
@@ -1579,6 +1581,7 @@ elif run_os == 'linux-androideabi' or run_os == 'linux-android':
     config.target_runtime = "native"
     config.target_swift_autolink_extract = inferSwiftBinary("swift-autolink-extract")
     config.target_sdk_name = "android"
+    config.target_library_path_var = "LD_LIBRARY_PATH"
     config.target_env_prefix = 'ANDROID_CHILD_'
     config.resource_dir_opt = ("-resource-dir %s" % test_resource_dir)
     # Since NDK r19, the headers and libraries are available in a unified
@@ -1792,24 +1795,51 @@ if run_vendor == 'apple':
     if 'back_deploy_concurrency' in config.available_features:
         concurrency_back_deploy_path = os.path.join(os.path.dirname(swift_obj_root), os.path.basename(swift_obj_root).replace("swift-", "backdeployconcurrency-"), 'lib', 'swift-5.5', run_os)
 
-if 'remote_run_host' in lit_config.params:
+def os_stdlib_paths():
+    if run_vendor == 'apple':
+        if run_os == 'maccatalyst':
+            return ["/System/iOSSupport/usr/lib/swift", "/usr/lib/swift"]
+        else:
+            return ["/usr/lib/swift"]
+    else:
+        lit_config.fatal("Unsupported platform for os_stdlib_paths")
+
+# This returns a shell variable assignment of the form <LIBRARY_PATH>=<VALUE>
+# where <LIBRARY_PATH> is whatever environment variable we need to set to
+# override dynamic library locations. (Usually DYLD_LIBRARY_PATH or
+# LD_LIBRARY_PATH, sometimes prefixed by a special annotation to tunnel the
+# setting through a helper tool.)
+#
+# The return value is designed to be passed to `/usr/bin/env` when executing a
+# binary on the test target.
+#
+# The single parameter is an array of directory paths that hold the libraries.
+def construct_library_path_env(dirs):
+    return "{0}{1}='{2}' ".format(
+        config.target_env_prefix,
+        config.target_library_path_var,
+        os.path.pathsep.join(dirs))
+
+def configure_remote_run():
     if 'remote_run_tmpdir' not in lit_config.params:
         lit_config.fatal("'remote_run_host' provided, but no "
                          "'remote_run_tmpdir'")
 
     remote_run_host = lit_config.params['remote_run_host']
     remote_tmp_dir = lit_config.params['remote_run_tmpdir']
     remote_lib_dir = os.path.join(remote_tmp_dir, 'stdlib')
-    remote_run_lib_path = ''
-    if 'use_os_stdlib' not in lit_config.params:
-        remote_run_lib_path = remote_lib_dir
-    else:
+    remote_run_lib_path = [remote_lib_dir]
+    if 'use_os_stdlib' in lit_config.params:
         config.available_features.add('use_os_stdlib')
-        os_stdlib_path = ''
-        if run_vendor == 'apple':
-            #If we get swift-in-the-OS for non-Apple platforms, add a condition here
-            os_stdlib_path = "/usr/lib/swift"
-        remote_run_lib_path = os.path.pathsep.join((os_stdlib_path, remote_lib_dir))
+        remote_run_lib_path = os_stdlib_paths() + [remote_lib_dir]
+        lit_config.note('Remote testing with the standard libraries in the OS')
+    elif 'back_deployment_runtime' in lit_config.params:
+        lit_config.note('Remote testing with back deployment libraries')
+    else:
+        lit_config.note('Remote testing with the just-built libraries')
+
+    lit_config.note(
+        'Remote library load path: {0}'.format(os.path.pathsep.join(remote_run_lib_path)))
 
     remote_run_extra_args_param = lit_config.params.get('remote_run_extra_args')
     remote_run_extra_args = shlex.split(remote_run_extra_args_param or '')
@@ -1858,16 +1888,14 @@ if 'remote_run_host' in lit_config.params:
 
     config.target_env_prefix = 'REMOTE_RUN_CHILD_'
     config.target_run = (
-        "/usr/bin/env "
-        "REMOTE_RUN_CHILD_DYLD_LIBRARY_PATH='{0}' " # Apple option
-        "REMOTE_RUN_CHILD_LD_LIBRARY_PATH='{0}' " # Linux option
-        "'{1}'/remote-run --input-prefix '{2}' --output-prefix %t "
-        "--remote-dir '{3}'%t {4} {5}".format(remote_run_lib_path,
-                                              config.swift_utils,
-                                              config.swift_src_root,
-                                              remote_tmp_dir,
-                                              ' '.join(remote_run_extra_args),
-                                              remote_run_host))
+        "/usr/bin/env " +
+        construct_library_path_env(remote_run_lib_path) +
+        "'{0}'/remote-run ".format(config.swift_utils) +
+        "--input-prefix '{0}' ".format(config.src_root) +
+        "--output-prefix %t " +
+        "--remote-dir '{0}'%t ".format(remote_tmp_dir) +
+        "{0} ".format(' '.join(remote_run_extra_args)) + 
+        "{0}".format(remote_run_host))
     config.target_swift_reflection_test = os.path.join(
         remote_tmp_dir, 'bin', swift_reflection_test_name)
     config.available_features.add('remote_run')
@@ -2048,42 +2076,40 @@ if 'concurrency' in config.available_features:
     else:
         config.available_features.add('concurrency_runtime')
 
-# Set up testing with the standard libraries coming from the OS / just-built libraries
-# default Swift tests to use the just-built libraries
-target_stdlib_path = platform_dylib_dir
-if not kIsWindows:
-	libdispatch_path = getattr(config, 'libdispatch_artifact_dir', '')
-	if 'use_os_stdlib' not in lit_config.params:
-		if run_os == 'maccatalyst':
-		    # Under macCatalyst we need to have the unzippered twin dylib dir come before
-		    # the zippered/macosx dylib dir so that unzippered twins are picked upload_dylibs
-		    # before the macOS variant.
-		    target_stdlib_path = "{0}:{1}".format(platform_module_dir, target_stdlib_path)
-		lit_config.note('Testing with the just-built libraries at ' + target_stdlib_path)
-		config.target_run = (
-			"/usr/bin/env "
-			"DYLD_LIBRARY_PATH='{0}' " # Apple option
-			"LD_LIBRARY_PATH='{0}:{1}' " # Linux option
-			"SIMCTL_CHILD_DYLD_LIBRARY_PATH='{0}' " # Simulator option
-			.format(target_stdlib_path, libdispatch_path)) + config.target_run
-	else:
-		config.available_features.add('use_os_stdlib')
-		os_stdlib_path = ''
-		if run_vendor == 'apple':
-			#If we get swift-in-the-OS for non-Apple platforms, add a condition here
-			os_stdlib_path = "/usr/lib/swift"
-			if run_os == 'maccatalyst':
-			    os_stdlib_path = "/System/iOSSupport/usr/lib/swift:/usr/lib/swift"
-
-		all_stdlib_path = os.path.pathsep.join((os_stdlib_path, concurrency_back_deploy_path, target_stdlib_path))
-
-		lit_config.note('Testing with the standard libraries coming from the OS ' + all_stdlib_path)
-		config.target_run = (
-			"/usr/bin/env "
-			"DYLD_LIBRARY_PATH='{0}' " # Apple option
-			"LD_LIBRARY_PATH='{0}:{1}' " # Linux option
-			"SIMCTL_CHILD_DYLD_LIBRARY_PATH='{0}' " # Simulator option
-			.format(all_stdlib_path, libdispatch_path)) + config.target_run
+# Set up testing with the standard libraries coming from either the OS, the back
+# deployment runtime or the just-built libraries. By default, we run tests with
+# the just-built libraries.
+target_stdlib_path = [platform_dylib_dir]
+if run_os == 'maccatalyst':
+    # Under macCatalyst we need to have the unzippered twin dylib dir come before
+    # the zippered/macosx dylib dir so that unzippered twins are picked upload_dylibs
+    # before the macOS variant.
+    target_stdlib_path = [platform_module_dir, platform_dylib_dir]
+
+if run_vendor != 'apple':
+    libdispatch_path = getattr(config, 'libdispatch_artifact_dir', None)
+    if libdispatch_path is not None:
+       target_stdlib_path.append(libdispatch_path)
+
+if 'remote-run-host' in lit_config.params:
+    configure_remote_run()
+elif not kIsWindows:
+    if 'use_os_stdlib' in lit_config.params:
+        config.available_features.add('use_os_stdlib')
+
+        target_stdlib_path = os_stdlib_paths() + [concurrency_back_deploy_path] + target_stdlib_path
+
+        lit_config.note('Testing with the standard libraries in the OS')
+    elif 'back_deployment_runtime' in lit_config.params:
+        lit_config.note('Testing with back deployment runtime libraries')
+    else:
+        lit_config.note('Testing with the just-built libraries')
+
+    lit_config.note('Library load path: {0}'.format(os.path.pathsep.join(target_stdlib_path)))
+    config.target_run = (
+        "/usr/bin/env " +
+        construct_library_path_env(target_stdlib_path) +
+        config.target_run)
 
 # When running with the JIT on Darwin, force the usage of the just built stdlib
 # when running the frontend. This is because we currently JIT in process