[libc++abi] Fix remote execution of .sh.cpp tests

[broadwaylamb]

Summary

This aims to fix test failures on the following buildbots:

• http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l
• http://lab.llvm.org:8011/builders/llvm-clang-win-x-aarch64

[broadwaylamb]

libcxx/utils/ssh.py

72

We're dealing with target-specific paths here. For now assume that the target uses POSIX paths.

libcxxabi/test/incomplete_type.sh.cpp

25–26

We need this because if both static and shared libc++abi are present, the linker will prefer the shared one. And if we're running this test viaSSH, we want to link it statically.

[ldionne]

I don't like adding a new substitution just to handle that specific configuration, but we can get rid of it soon when we simplify the config files anyway.

Other changes for posixpath & al look obviously right.

[broadwaylamb]

In D77190#1954800, @ldionne wrote:

I don't like adding a new substitution just to handle that specific configuration, but we can get rid of it soon when we simplify the config files anyway.

That's what I thought. This patch is mostly for making builders green.

libcxx/utils/libcxx/compiler.py

def __init__(self, config, path, flags=None, compile_flags=None, link_flags=None,
                  use_ccache=False, use_warnings=False, compile_env=None,
                  cxx_type=None, cxx_version=None):
         self.libcxx_config = config
         self.source_lang = 'c++'
         self.path = path
         self.flags = list(flags or [])
         self.compile_flags = list(compile_flags or [])
         self.link_flags = list(link_flags or [])
+        self.link_libcxxabi_flag = '-lc++abi'
         self.warning_flags = list(warning_flags or [])
         self.verify_supported = verify_supported
         self.use_verify = use_verify
         self.verify_flags = list(verify_flags or [])
         assert not use_verify or verify_supported
         assert not use_verify or verify_flags is not None
         self.modules_flags = list(modules_flags or [])
         self.use_modules = use_modules

libcxx/utils/libcxx/test/config.py

def configure_link_flags_abi_library(self):
                 libcxxabi_shared = self.get_lit_bool('libcxxabi_shared', default=True)
                 if libcxxabi_shared:
                     self.cxx.link_flags += ['-lc++abi']
                 else:
                     cxxabi_library_root = self.get_lit_conf('abi_library_path')
                     if cxxabi_library_root:
                         libname = self.make_static_lib_name('c++abi')
                         abs_path = os.path.join(cxxabi_library_root, libname)
+                        self.cxx.link_libcxxabi_flag = abs_path
                         self.cxx.link_flags += [abs_path]
                     else:
                         self.cxx.link_flags += ['-lc++abi']
         elif cxx_abi == 'libcxxrt':
             self.cxx.link_flags += ['-lcxxrt']
         elif cxx_abi == 'vcruntime':
             debug_suffix = 'd' if self.debug_build else ''
             self.cxx.link_flags += ['-l%s%s' % (lib, debug_suffix) for lib in
def configure_substitutions(self):
         sub = self.config.substitutions
         # Configure compiler substitutions
         sub.append(('%{cxx}', '{} {}'.format(tool_env, pipes.quote(self.cxx.path))))
         sub.append(('%{libcxx_src_root}', self.libcxx_src_root))
         # Configure flags substitutions
         sub.append(('%{flags}',         ' '.join(map(pipes.quote, self.cxx.flags))))
         sub.append(('%{compile_flags}', ' '.join(map(pipes.quote, self.cxx.compile_flags))))
         sub.append(('%{link_flags}',    ' '.join(map(pipes.quote, self.cxx.link_flags))))
+        sub.append(('%{link_libcxxabi}', pipes.quote(self.cxx.link_libcxxabi_flag)))
         if self.cxx.isVerifySupported():
             sub.append(('%{verify}', ' '.join(self.cxx.verify_flags)))
         # Add compile and build shortcuts
         sub.append(('%{compile}', '%{cxx} -o %t.o %s -c %{flags} %{compile_flags}'))
         sub.append(('%{build}',   '%{cxx} -o %t.exe %s %{flags} %{compile_flags} %{link_flags}'))
         if self.cxx.use_modules:
             sub.append(('%{build_module}', '%{build}'))
         elif self.cxx.modules_flags is not None:

libcxx/utils/libcxx/test/format.py

def _execute(self, test, lit_config):
         if lit_config.noExecute:
             return lit.Test.Result(lit.Test.PASS)
 
         # Check that we don't have run lines on tests that don't support them.
         if not is_sh_test and len(script) != 0:
             lit_config.fatal('Unsupported RUN line found in test %s' % name)
 
         tmpDir, tmpBase = lit.TestRunner.getTempPaths(test)
-        substitutions = lit.TestRunner.getDefaultSubstitutions(test, tmpDir,
-                                                               tmpBase)
+        substitutions = lit.TestRunner.getDefaultSubstitutions(
+            test, tmpDir, tmpBase, normalize_slashes=self.execute_external)
 
         # Apply substitutions in FILE_DEPENDENCIES markup
         data_files = lit.TestRunner.applySubstitutions(test.file_dependencies, substitutions,
                                                        recursion_limit=10)
         local_cwd = os.path.dirname(test.getSourcePath())
         data_files = [f if os.path.isabs(f) else os.path.join(local_cwd, f) for f in data_files]
         substitutions.append(('%{file_dependencies}', ' '.join(data_files)))
 

libcxx/utils/ssh.py

 Runs an executable on a remote host.
 
 This is meant to be used as an executor when running the C++ Standard Library
 conformance test suite.
 """
 
 import argparse
 import os
+import posixpath
 import subprocess
 import sys
 
 
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--host', type=str, required=True)
     parser.add_argument('--codesign_identity', type=str, required=False)
if exe and args.codesign_identity:
         if rc != 0:
             sys.stderr.write('Failed to codesign: {}'.format(exe))
             return rc
 
     ssh = lambda command: ['ssh', '-oBatchMode=yes', args.host, command]
     scp = lambda src, dst: ['scp', '-oBatchMode=yes', '-r', src, '{}:{}'.format(args.host, dst)]
 
     # Create a temporary directory where the test will be run
-    tmp = subprocess.check_output(ssh('mktemp -d /tmp/libcxx.XXXXXXXXXX')).strip()
+    tmp = subprocess.check_output(ssh('mktemp -d /tmp/libcxx.XXXXXXXXXX'), universal_newlines=True).strip()
 
     # Ensure the test dependencies exist and scp them to the temporary directory.
     # Test dependencies can be either files or directories, so the `scp` command
     # needs to use `-r`.
     for dep in args.dependencies:
         if not os.path.exists(dep):
             sys.stderr.write('Missing file or directory {} marked as a dependency of a test'.format(dep))
             exit(1)
         subprocess.call(scp(dep, tmp))
 
     # If there's an executable, change its path to be in the temporary directory.
     # We know it has been copied to the remote host when we handled the test
     # dependencies above.
     if exe:
-        exe = os.path.join(tmp, os.path.basename(exe))
+        exe = posixpath.join(tmp, os.path.basename(exe))
 
     # If there's an executable, make sure it has 'execute' permissions on the
     # remote host. The host that compiled the executable might not have a notion
     # of 'executable' permissions.
     if exe:
         subprocess.call(ssh('chmod +x {}'.format(exe)))
 
     # Execute the command through SSH in the temporary directory, with the

libcxxabi/test/incomplete_type.sh.cpp

 // Two abi::__pbase_type_info objects can always be compared for equality
 // (i.e. of the types represented) or ordering by comparison of their name
 // NTBS addresses. In addition, unless either or both have either of the
 // incomplete flags set, equality can be tested by comparing the type_info
 // addresses.
 
 // UNSUPPORTED: libcxxabi-no-exceptions
 
-// NOTE: Pass -lc++abi explicitly and before -lc++ so that -lc++ doesn't drag
+// NOTE: Link libc++abi explicitly and before libc++ so that libc++ doesn't drag
 // in the system libc++abi installation on OS X. (DYLD_LIBRARY_PATH is ignored
 // for shell tests because of Apple security features).
 
+// FILE_DEPENDENCIES: %t.exe
 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.one.o
 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.two.o -DTU_ONE
-// RUN: %{cxx} %{flags} %t.one.o %t.two.o -lc++abi %{link_flags} -o %t.exe
-// RUN: %t.exe
+// RUN: %{cxx} %{flags} %t.one.o %t.two.o %{link_libcxxabi} %{link_flags} -o %t.exe
+// RUN: %{exec} %t.exe
 
 #include <stdio.h>
 #include <cstring>
 #include <cassert>
 #include <typeinfo>
 
 // Check that the addresses of the typeinfo differ but still compare equal
 // via their NTBS.