[lldb] [test] Pass appropriate -L&-Wl,-rpath for libc++ on NetBSD

[mgorny]

Summary

Pass appropriate -L and -Wl,-rpath flags pointing out to the LLVM
library directory on NetBSD. This is necessary since clang on NetBSD
requires libc++ but it is not installed as part of the system
by default. For the purpose of running buildbot, we want LLDB to use
just-built libc++.

[labath]

Unfortunately I don't know of a substantially better way to solve. I have one small improvement inline. Also, I take it this means running tests without a libc++ checkout is not supported on NetBSD. Maybe you should add netbsd to the cmake code where we print the darwin warning if you build without libc++ checked out.

lldb/lit/Suite/lit.cfg

35–36

Instead of passing this via the environment, you should arrange so that --env LLVM_LIBS_DIR=dir gets passed to dotest.py. This will stop people from pounding the head against the wall on why do the tests behave differently when run from lit vs. directly from command line.

[mgorny]

In D58630#1410419, @labath wrote:

Unfortunately I don't know of a substantially better way to solve. I have one small improvement inline. Also, I take it this means running tests without a libc++ checkout is not supported on NetBSD. Maybe you should add netbsd to the cmake code where we print the darwin warning if you build without libc++ checked out.

Actually, it can use either libc++ checkout or installed libc++. it just happens that the latter is uncommon.

[mgorny]

Turns out LD_LIBRARY_PATH does not solve all the issues on NetBSD. I've went ahead with the simplest solution possible, and added -Wl,-rpath (only on NetBSD) along with -L flags.

[mgorny]

Updated to make it all conditional to NetBSD, as discussed.

lldb/lit/BuildScript/toolchain-clang.test

 RUN: %build -n --verbose --arch=32 --compiler=clang --mode=compile-and-link -o %t/foo.exe foobar.c \
 RUN:    | FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
 
 RUN: %build -n --verbose --arch=64 --compiler=clang --mode=compile-and-link -o %t/foo.exe foobar.c \
 RUN:    | FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
 
 CHECK: Cleaning {{.*}}toolchain-clang.test.tmp{{.}}foo.exe-foobar.o
 CHECK: Cleaning {{.*}}toolchain-clang.test.tmp{{.}}foo.exe
 CHECK: compiling foobar.c -> foo.exe-foobar.o
 CHECK-32: {{.*}}clang++{{(.exe)?}} -m32 -g -O0 -c -o {{.*}}foo.exe-foobar.o {{.*}}foobar.c
 CHECK-64: {{.*}}clang++{{(.exe)?}} -m64 -g -O0 -c -o {{.*}}foo.exe-foobar.o {{.*}}foobar.c
 CHECK: linking foo.exe-foobar.o -> foo.exe
-CHECK-32: {{.*}}clang++{{(.exe)?}} -m32 -o {{.*}}foo.exe {{.*}}foo.exe-foobar.o
-CHECK-64: {{.*}}clang++{{(.exe)?}} -m64 -o {{.*}}foo.exe {{.*}}foo.exe-foobar.o
+CHECK-32: {{.*}}clang++{{(.exe)?}} -m32 {{(-L.*)?}} -o {{.*}}foo.exe {{.*}}foo.exe-foobar.o
+CHECK-64: {{.*}}clang++{{(.exe)?}} -m64 {{(-L.*)?}} -o {{.*}}foo.exe {{.*}}foo.exe-foobar.o

lldb/lit/Suite/lit.cfg

if 'Address' in config.llvm_use_sanitizer and \
   resource_dir = subprocess.check_output(
     config.cmake_cxx_compiler +' -print-resource-dir', shell=True).strip()
   runtime = os.path.join(resource_dir, 'lib', 'darwin',
                          'libclang_rt.asan_osx_dynamic.dylib')
   config.environment['ASAN_OPTIONS'] = \
     'detect_stack_use_after_return=1'
   config.environment['DYLD_INSERT_LIBRARIES'] = runtime
 
+# Library path may be needed to locate just-built clang.
+config.environment['LLVM_LIBS_DIR'] = config.llvm_libs_dir
+
 # Build dotest command.
 dotest_cmd = [config.dotest_path, '-q']
 dotest_cmd.extend(config.dotest_args_str.split(';'))
 
 # We don't want to force users passing arguments to lit to use `;` as a
 # separator. We use Python's simple lexical analyzer to turn the args into a
 # list.
 if config.dotest_lit_args_str:
   dotest_cmd.extend(shlex.split(config.dotest_lit_args_str))
 
 # Load LLDB test format.
 sys.path.append(os.path.join(config.lldb_src_root, "lit", "Suite"))
 import lldbtest
 
 # testFormat: The test format to use to interpret tests.
 config.test_format = lldbtest.LLDBTest(dotest_cmd)

lldb/lit/helper/build.py

parser.add_argument('--arch',
                     help='Specify the architecture to target.')
 
 parser.add_argument('--compiler',
                     metavar='compiler',
                     dest='compiler',
                     required=True,
                     help='Path to a compiler executable, or one of the values [any, msvc, clang-cl, gcc, clang]')
 
+parser.add_argument('--libs-dir',
+                    metavar='directory',
+                    dest='libs_dir',
+                    required=False,
+                    action='append',
+                    help='If specified, a path to linked libraries to be passed via -L')
+
 parser.add_argument('--tools-dir',
                     metavar='directory',
                     dest='tools_dir',
                     required=False,
                     action='append',
                     help='If specified, a path to search in addition to PATH when --compiler is not an exact path')
 
 if sys.platform == 'darwin':
def __init__(self, toolchain_type, args, obj_ext):
         self.outdir = args.outdir
         self.compiler = args.compiler
         self.clean = args.clean
         self.output = args.output
         self.mode = args.mode
         self.nodefaultlib = args.nodefaultlib
         self.verbose = args.verbose
         self.obj_ext = obj_ext
+        self.lib_paths = args.libs_dir
 
     def _exe_file_name(self):
         assert self.mode != 'compile'
         return self.output
 
     def _output_name(self, input, extension, with_executable=False):
         basename = os.path.splitext(os.path.basename(input))[0] + extension
         if with_executable:
def _get_link_command(self):
         args.append('-m' + self.arch)
         if self.nodefaultlib:
             args.append('-nostdlib')
             args.append('-static')
             main_symbol = 'main'
             if sys.platform == 'darwin':
                 main_symbol = '_main'
             args.append('-Wl,-e,' + main_symbol)
+        args.extend(['-L' + x for x in self.lib_paths])
         args.extend(['-o', self._exe_file_name()])
         args.extend(self._obj_file_names())
 
         return ('linking', self._obj_file_names(), self._exe_file_name(), None, args)
 
 
     def output_files(self):
         outputs = []

lldb/lit/helper/toolchain.py

def use_lldb_substitutions(config):
     build_script = os.path.join(build_script, 'build.py')
     build_script_args = [build_script,
                         '--compiler=any', # Default to best compiler
                         '--arch=' + str(config.lldb_bitness)]
     if config.lldb_lit_tools_dir:
         build_script_args.append('--tools-dir={0}'.format(config.lldb_lit_tools_dir))
     if config.lldb_tools_dir:
         build_script_args.append('--tools-dir={0}'.format(config.lldb_tools_dir))
+    if config.llvm_libs_dir:
+        build_script_args.append('--libs-dir={0}'.format(config.llvm_libs_dir))
 
     primary_tools = [
         ToolSubst('%lldb',
                   command=FindTool('lldb'),
                   extra_args=['--no-lldbinit', '-S',
                               os.path.join(config.test_source_root,
                                            'lit-lldb-init')]),
         lldbmi,
if platform.system() in ['Darwin']:
             res = -1
         if res == 0 and out:
             sdk_path = lit.util.to_string(out)
             llvm_config.lit_config.note('using SDKROOT: %r' % sdk_path)
             flags = ['-isysroot', sdk_path]
     elif platform.system() in ['OpenBSD', 'Linux']:
         flags = ['-pthread']
 
+    # needed e.g. to use freshly built libc++
+    flags.append('-L' + config.llvm_libs_dir)
 
     additional_tool_dirs=[]
     if config.lldb_lit_tools_dir:
         additional_tool_dirs.append(config.lldb_lit_tools_dir)
 
     llvm_config.use_clang(additional_flags=flags,
                           additional_tool_dirs=additional_tool_dirs,
                           required=True)

lldb/packages/Python/lldbsuite/test/make/Makefile.rules

ifeq "$(MAKE_GMODULES)" "YES"
   CFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
   CXXFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
 endif
 
 CXXFLAGS += -std=c++11 $(CFLAGS) $(ARCH_CXXFLAGS)
 LD = $(CC)
 LDFLAGS ?= $(CFLAGS)
 LDFLAGS += $(LD_EXTRAS) $(ARCH_LDFLAGS)
+ifneq (,$(LLVM_LIBS_DIR))
+  LDFLAGS += -L$(LLVM_LIBS_DIR)
+endif
 ifeq (,$(filter $(OS), Windows_NT Android Darwin))
   ifneq (,$(filter YES,$(ENABLE_THREADS)))
     LDFLAGS += -pthread
   endif
 endif
 OBJECTS =
 EXE ?= a.out